static void Main(string[] args) { update_bases(); TcpListener Listen = new TcpListener(IPAddress.Any, 1488); Listen.Start(); Console.WriteLine("[Server is online]"); int games = 0; while (true) { //кто-то подсоединился TcpClient Client = Listen.AcceptTcpClient(); Console.Write("[Client connected!]"); NetworkStream ns = Client.GetStream(); //Проверяем, есть ли кто-то в очереди if (Waiter != null) { //в очереди кто-то есть, создаем новую игру Games.Add(new Game(games++, Waiter, Client, timeOfGame, GenerateWord())); Waiter = null; } else { //очеред пуста, закидываем туда клиента Waiter = Client; } } }
static void Main(string[] args) { TcpListener server = null; try { Int32 port = Convert.ToInt32(args[0]); IPAddress localAddr = IPAddress.Parse("127.0.0.1"); server = new TcpListener(localAddr, port); server.Start(); int numberOfClients = 0; while (true) { Console.WriteLine("Waiting for a connection..."); TcpClient client = server.AcceptTcpClient(); Console.WriteLine((++numberOfClients).ToString() + " Connected!"); HandleClient handleClient = new HandleClient(client); Thread myThread = new Thread(new ThreadStart(handleClient.Communicate)); myThread.Name = Convert.ToString(numberOfClients); myThread.IsBackground = true; myThread.Start(); } } finally { server.Stop(); } }
public Server() { port = 41337; listener = new TcpListener(port); otherListener = new TcpListener(41338); streams = new List<NetworkStream>(); }
/// <summary> /// Start a HTTP server. /// </summary> /// <param name="port">Port number.</param> public bool StartServer(int port) { try { Debug.Log("Starting a server..."); server = new TcpListener(IPAddress.Parse("127.0.0.1"), port); server.Start(); listenThread = new Thread(Listen); listenThread.Start(); Debug.Log("The server is started."); } catch (Exception e) { Debug.LogError(e); if (server != null) server.Stop(); server = null; return false; } return true; }
public void Start() { TcpListener listener = new TcpListener(IPAddress, Port); listener.Start(); Console.WriteLine("Server is running, good luck!"); while (true) { var client = new NetworkClient(listener.AcceptTcpClient()); connectedClients.Add(client); Task.Factory.StartNew(() => { try { HandleConnectedClient(client); } catch (Exception ex) { Console.WriteLine(ex.Message); Console.WriteLine(ex.StackTrace); } },TaskCreationOptions.LongRunning); Console.WriteLine("User Connected. Now you have {0} users connected", connectedClients.Count); } }
Program() { IPAddress ip = Info.GetIp(); TcpListener listener = new TcpListener(ip,Info.Port); storage = new DataStorage(); listener.Start(); int counter = 0; Console.WriteLine("Server started: {0}",DateTime.Now); Console.WriteLine("Server ip: {0}", ip); Console.WriteLine("Server port: {0}",Info.Port); while (true) { TcpClient newClient = listener.AcceptTcpClient(); if (!IsMonitor(newClient)) { counter++; Console.WriteLine("is client"); Client client = new Client(newClient, this, counter, storage); clients.Add(client); } else if (_monitor != null) { if (!_monitor.TcpClient.Connected) { _monitor = new Monitor(newClient,this,clients, storage); } } else { _monitor = new Monitor(newClient,this,clients, storage); } } }
public DispatchLoop(TcpListener listener, ILogger logger, IProtocolFactory protoFactory) { this.listener = listener; this.logger = logger; this.protoFactory = protoFactory; }
public void StartServer() { TcpListener server = new TcpListener(IPAddress.Parse("192.168.0.13"), 14500); server.Start(); Console.WriteLine("Server has started on 127.0.0.1:14500.{0}Waiting for a connection...", Environment.NewLine); while (true) { Socket client = server.AcceptSocket(); Console.WriteLine("A client connected."); var childSocketThread = new Thread(() => { byte[] data = new byte[4096]; int size = client.Receive(data); if (size > 4096) //the packet is too god damn high { Console.Write("Client tried to send packet above 4096 bytes"); return; } HandlePacket(client,data); Console.WriteLine("Recieved data:"); for (int i = 0; i < size; i++) { Console.Write(Convert.ToChar(data[i])); } Console.WriteLine(); client.Close(); }); childSocketThread.Start(); } }
public static void Main() { TcpListener tcpListener = new TcpListener(10); tcpListener.Start(); Socket socketForClient = tcpListener.AcceptSocket(); if (socketForClient.Connected) { Console.WriteLine("Client connected"); NetworkStream networkStream = new NetworkStream(socketForClient); System.IO.StreamWriter streamWriter = new System.IO.StreamWriter(networkStream); System.IO.StreamReader streamReader = new System.IO.StreamReader(networkStream); string theString = "Sending"; streamWriter.WriteLine(theString); Console.WriteLine(theString); streamWriter.Flush(); theString = streamReader.ReadLine(); Console.WriteLine(theString); streamReader.Close(); networkStream.Close(); streamWriter.Close(); } socketForClient.Close(); Console.WriteLine("Exiting..."); }
public static int GetFreePort() { TcpListener tcpListener = default(TcpListener); int port = 0; try { var ipAddress = Dns.GetHostEntry("localhost").AddressList[0]; tcpListener = new TcpListener(ipAddress, 0); tcpListener.Start(); string s = tcpListener.LocalEndpoint.ToString(); s = s.Substring(s.IndexOf("]:")+2); port = int.Parse(s); return port; } catch (SocketException) { } finally { if (tcpListener != null) tcpListener.Stop(); } return port; }
public static void Main(String[] args) { TcpListener server=null; try { //Echo servers listen on port 7 int portNumber = 7; //Echo server first binds to port 7 server = new TcpListener(portNumber); //Server starts listening server.Start(); //Echo server loops forever, listening for clients for(;;) { //Accept the pending client connection and return a client //initialized for communication //This method will block until a connection is made EchoServer es = new EchoServer(server.AcceptTcpClient()); //Allow this conversation to run in a new thread Thread serverThread = new Thread( new ThreadStart(es.Conversation)); serverThread.Start(); //Loop back up and wait for another client //Another thread is servicing this client } } catch (Exception e) { Console.WriteLine(e+" "+e.StackTrace); } finally { //Release the port and stop the server server.Stop(); } }
internal ServerState() { this.PortNumber = String.Empty; this.Password = String.Empty; this.MainPort = null; this.Clients = new Dictionary<String, TaskInfo>(); this.wChatClipboard = null; this.Transmitting = false; this.WorkEnd = false; this.VideoOn = false; this.SelectingArea = false; this.StreamingSem = null; this.Spawner = null; this.Transfer = null; this.Streamer = null; this.Area = new Rectangle(0,0,0,0); this.hWnd = IntPtr.Zero; this.dUpdateHistory = null; this.dUpdateClipboard = null; this.dSendClipboard = null; this.PreviousBMP = null; this.CurrentBMP = null; this.SelectedWindowOffsetX = 0; this.SelectedWindowOffsetY = 0; }
public static void Run() { var listener = new TcpListener(IPAddress.Loopback, 8181); listener.Start(); using (var client = listener.AcceptTcpClient()) using (var stream = client.GetStream()) using (var reader = new StreamReader(stream)) using (var writer = new StreamWriter(stream)) { Console.WriteLine(reader.ReadLine()); Console.WriteLine(reader.ReadLine()); Console.WriteLine(reader.ReadLine()); Console.WriteLine(reader.ReadLine()); Console.WriteLine(reader.ReadLine()); Console.WriteLine(reader.ReadLine()); writer.WriteLine("HTTP/1.1 101 Web Socket Protocol Handshake"); writer.WriteLine("Upgrade: WebSocket"); writer.WriteLine("Connection: Upgrade"); writer.WriteLine("WebSocket-Origin: http://localhost:8080"); writer.WriteLine("WebSocket-Location: ws://localhost:8181/websession"); writer.WriteLine(""); } listener.Stop(); }
public void Run() { _broadcaster = new Broadcaster(); IPAddress ip = IPAddress.Parse(_servername); TcpListener listener = new TcpListener(ip, _port); /* Gør så at serveren kan skrive input*/ Thread serverInputThread = new Thread(HandleInput); serverInputThread.Start(); _running = true; listener.Start(); Console.WriteLine("Skriv \'new\' for at starte en ny auktion."); while (_running) { System.Console.WriteLine("Server klar til bruger"); /* En socket forbinder*/ Socket clientSocket = listener.AcceptSocket(); /* Lav en ny client handler til forbindelsen */ ClientHandler handler = new ClientHandler(clientSocket, _broadcaster); handler.SetAuction(_auction); /* Start det i en ny tråd */ Thread clientThread = new Thread(handler.RunClient); /* Start trådene */ clientThread.Start(); } }
public void BeginLister() { while (true) { try { IPAddress[] Ips = Dns.GetHostAddresses(""); string GetIp = Ips[0].ToString(); Listener = new TcpListener(IPAddress .Parse (GetIp ),8888); Listener.Start(); CheckForIllegalCrossThreadCalls = false; butBeginSever.Enabled = false; this.Text = "服务器已经开启....."; SocketClient = Listener.AcceptSocket(); NetStream = new NetworkStream(SocketClient ); ServerWriter = new StreamWriter(NetStream ); ServerReader = new StreamReader(NetStream ); if (SocketClient.Connected) { MessageBox.Show("客户端连接成功!","服务器消息",MessageBoxButtons .OK ,MessageBoxIcon.Information ); } } catch { } } }
public void Start(int port) { if (listener != null && listener.Server.IsBound) { return; } this.port = port; IPEndPoint ipEnd = new IPEndPoint(IPAddress.Any, port); listener = new TcpListener(ipEnd); try { listener.Start(); running = true; if (LOGGER.IsInfoEnabled) { LOGGER.Info("Push Server Simulator is successfully started on port " + port.ToString()); } } catch (Exception e) { if (LOGGER.IsErrorEnabled) { LOGGER.Error("Error occured while trying to start Push Server Simulator on port " + port.ToString() + " . Message: " + e.Message); } } thread = new Thread(new ThreadStart(listen)); thread.Start(); }
public int Start () { bool processed; Console.WriteLine ("Touch.Unit Simple Server listening on: {0}:{1}", Address, Port); server = new TcpListener (Address, Port); try { server.Start (); do { using (TcpClient client = server.AcceptTcpClient ()) { processed = Processing (client); } } while (!AutoExit || !processed); } catch (Exception e) { Console.WriteLine ("[{0}] : {1}", DateTime.Now, e); return 1; } finally { server.Stop (); } return 0; }
public static void Main(string[] args) { Console.WriteLine("Server start"); int port = 55555; var listener = new TcpListener(IPAddress.Loopback, port); listener.Start(); Console.WriteLine("start listening"); var client = listener.AcceptTcpClientAsync().Result; var stream = client.GetStream(); var reader = new StreamReader(stream); Console.WriteLine("Connected"); var data = reader.ReadLine(); if (data == null) { Console.WriteLine("data is null"); } else { Console.WriteLine(data); } }
public Server(CallResponseQueue queue) { this.queue = queue; this.tcpListener = new TcpListener(IPAddress.Loopback, 3000); this.listenThread = new Thread(new ThreadStart(ListenForClients)); this.listenThread.Start(); }
/// <summary> /// Creates a pair of connected NetworkStreams and invokes the provided <paramref name="func"/> /// with them as arguments. /// </summary> private static async Task RunWithConnectedNetworkStreamsAsync(Func<NetworkStream, NetworkStream, Task> func) { var listener = new TcpListener(IPAddress.Loopback, 0); try { listener.Start(1); var clientEndpoint = (IPEndPoint)listener.LocalEndpoint; using (var client = new TcpClient(clientEndpoint.AddressFamily)) { Task<TcpClient> remoteTask = listener.AcceptTcpClientAsync(); Task clientConnectTask = client.ConnectAsync(clientEndpoint.Address, clientEndpoint.Port); await Task.WhenAll(remoteTask, clientConnectTask); using (TcpClient remote = remoteTask.Result) using (NetworkStream serverStream = remote.GetStream()) using (NetworkStream clientStream = client.GetStream()) { await func(serverStream, clientStream); } } } finally { listener.Stop(); } }
BlockingTcpListener(Loop loop) : base(loop) { TcpListener = new TcpListener(loop); Listener = TcpListener as Listener; Handle = TcpListener; }
public void Start () { tcpListener = new TcpListener (LocalEndPoint); tcpListener.Start (); listenThread = new Thread (new ThreadStart (Listen)); listenThread.Start (); }
/// <summary> /// Gets request from client, and sends back file/folder to encrypt /// </summary> static void handleRequest(TcpListener listener) { while (true) { int bytesRead; byte[] buffer = new byte[1024]; string test = null; Socket s = listener.AcceptSocket(); Console.WriteLine("Connection accepted from " + s.RemoteEndPoint); bytesRead = s.Receive(buffer); char cc = ' '; Console.WriteLine("Recieved..."); for (int i = 0; i < bytesRead - 1; i++) { //Console.Write(Convert.ToChar(buffer[i])); cc = Convert.ToChar(buffer[i]); test += cc.ToString(); } Console.WriteLine(test); string message = "files encrypted."; ASCIIEncoding asen = new ASCIIEncoding(); s.Send(asen.GetBytes(message)); s.Close(); Console.WriteLine("sent bytes back"); } }
static void Main(string[] args) { byte[] quote = Encoding.ASCII.GetBytes("Insanity: doing the same thing over and over again and expecting different results. - Albert Einstein"); var loop = new UVLoop(); var listener = new TcpListener("0.0.0.0", 17, loop); listener.ConnectionAccepted += (Tcp connection) => { connection.ReadCompleted += (ByteSpan data) => { unsafe { fixed (byte* pQuote = quote) { connection.TryWrite(new ByteSpan(pQuote, quote.Length)); } } }; connection.ReadStart(); }; listener.Listen(); loop.Run(); }
public static void Main(String[] args) { TcpListener server = new TcpListener(int.Parse(args[0])); server.Start(); TcpClient client = server.AcceptTcpClient(); NetworkStream stream = client.GetStream(); StreamReader reader = new StreamReader(stream); String s = reader.ReadLine(); String[] strings = s.Split(); StreamWriter writer; if (strings[0] != "GET") { writer = new StreamWriter(stream); writer.WriteLine ("HTTP/1.0 501 Not Implemented"); writer.WriteLine(); } else { String filename = strings[1]; while(reader.ReadLine() != ""); writer = new StreamWriter(stream); writer.WriteLine("HTTP/1.0 200 OK"); writer.WriteLine("Content-type: text/plain"); writer.WriteLine(); StreamReader file = new StreamReader(filename); String z = file.ReadToEnd(); writer.WriteLine(z); writer.Flush(); writer.Close(); file.Close(); } client.Close(); stream.Close(); reader.Close(); writer.Close(); server.Stop(); }
/* Constructor */ public Server() { //create folder "Plugins" if it doesn't already exists _PluginLocation=Environment.CurrentDirectory; _PluginLocation += "\\Plugins\\"; if (!Directory.Exists(_PluginLocation)) { try { Directory.CreateDirectory(_PluginLocation); } catch (Exception e) { Console.WriteLine(e.Message + "- Plugin-Folder could not be created"); Console.ReadLine(); Environment.Exit(1); } } try { //create listener - second param = port TcpListener = new TcpListener(IPAddress.Any, 8080); } catch (Exception) { throw; } }
protected override void Execute() { TcpListener server = null; NetworkStream stream = null; TcpClient client = null; server = new TcpListener(8080); server.Start(); byte[] buffer = new byte[150 * 1024]; int i = 0; logger.Log("Thread Start"); for(;;){ client = server.AcceptTcpClient(); stream = client.GetStream(); while ((i = stream.Read(buffer, 0, buffer.Length)) != 0){ retrievedPacket(i, buffer); i = 0; if(terminate) break; } client.Close(); Thread.Sleep(1000 / 30); if(terminate) break; } server.Stop(); logger.Log("Thread Stop"); }
} // end method DisplayMessage // accepts connections from 2 players public void SetUp() { DisplayMessage("Waiting for players...\r\n"); // set up Socket listener = new TcpListener(IPAddress.Parse("127.0.0.1"), 50000); listener.Start(); // accept first player and start a player thread players[0] = new Player(listener.AcceptSocket(), this, 0); playerThreads[0] = new Thread(new ThreadStart(players[0].Run)); playerThreads[0].Start(); // accept second player and start another player thread players[1] = new Player(listener.AcceptSocket(), this, 1); playerThreads[1] = new Thread(new ThreadStart(players[1].Run)); playerThreads[1].Start(); // let the first player know that the other player has connected lock (players[0]) { players[0].threadSuspended = false; Monitor.Pulse(players[0]); } // end lock } // end method SetUp
// the listener thread's listen function // note: no maxConnections parameter. high level API should handle that. // (Transport can't send a 'too full' message anyway) void Listen(int port) { // absolutely must wrap with try/catch, otherwise thread // exceptions are silent try { // start listener on all IPv4 and IPv6 address via .Create listener = TcpListener.Create(port); listener.Server.NoDelay = NoDelay; listener.Server.SendTimeout = SendTimeout; listener.Server.ReceiveTimeout = ReceiveTimeout; listener.Start(); Log.Info("Server: listening port=" + port); // keep accepting new clients while (true) { // wait and accept new client // note: 'using' sucks here because it will try to // dispose after thread was started but we still need it // in the thread TcpClient client = listener.AcceptTcpClient(); // set socket options client.NoDelay = NoDelay; client.SendTimeout = SendTimeout; client.ReceiveTimeout = ReceiveTimeout; // generate the next connection id (thread safely) int connectionId = NextConnectionId(); // add to dict immediately ConnectionState connection = new ConnectionState(client, MaxMessageSize); clients[connectionId] = connection; // spawn a send thread for each client Thread sendThread = new Thread(() => { // wrap in try-catch, otherwise Thread exceptions // are silent try { // run the send loop // IMPORTANT: DO NOT SHARE STATE ACROSS MULTIPLE THREADS! ThreadFunctions.SendLoop(connectionId, client, connection.sendPipe, connection.sendPending); } catch (ThreadAbortException) { // happens on stop. don't log anything. // (we catch it in SendLoop too, but it still gets // through to here when aborting. don't show an // error.) } catch (Exception exception) { Log.Error("Server send thread exception: " + exception); } }); sendThread.IsBackground = true; sendThread.Start(); // spawn a receive thread for each client Thread receiveThread = new Thread(() => { // wrap in try-catch, otherwise Thread exceptions // are silent try { // run the receive loop // (receive pipe is shared across all loops) ThreadFunctions.ReceiveLoop(connectionId, client, MaxMessageSize, receivePipe, ReceiveQueueLimit); // IMPORTANT: do NOT remove from clients after the // thread ends. need to do it in Tick() so that the // disconnect event in the pipe is still processed. // (removing client immediately would mean that the // pipe is lost and the disconnect event is never // processed) // sendthread might be waiting on ManualResetEvent, // so let's make sure to end it if the connection // closed. // otherwise the send thread would only end if it's // actually sending data while the connection is // closed. sendThread.Interrupt(); } catch (Exception exception) { Log.Error("Server client thread exception: " + exception); } }); receiveThread.IsBackground = true; receiveThread.Start(); } } catch (ThreadAbortException exception) { // UnityEditor causes AbortException if thread is still // running when we press Play again next time. that's okay. Log.Info("Server thread aborted. That's okay. " + exception); } catch (SocketException exception) { // calling StopServer will interrupt this thread with a // 'SocketException: interrupted'. that's okay. Log.Info("Server Thread stopped. That's okay. " + exception); } catch (Exception exception) { // something went wrong. probably important. Log.Error("Server Exception: " + exception); } }
public override void Bad() { int data; if (IO.StaticReturnsTrueOrFalse()) { data = int.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); listener.Start(); using (TcpClient tcpConn = listener.AcceptTcpClient()) { /* read input from socket */ using (StreamReader sr = new StreamReader(tcpConn.GetStream())) { /* POTENTIAL FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = int.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { try { if (listener != null) { listener.Stop(); } } catch (SocketException se) { IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener"); } } } } else { /* FIX: Use a hardcoded number that won't cause underflow, overflow, divide by zero, or loss-of-precision issues */ data = 2; } if (IO.StaticReturnsTrueOrFalse()) { /* POTENTIAL FLAW: Zero modulus will cause an issue. An integer division will * result in an exception. */ IO.WriteLine("100%" + data + " = " + (100 % data) + "\n"); } else { /* FIX: test for a zero modulus */ if (data != 0) { IO.WriteLine("100%" + data + " = " + (100 % data) + "\n"); } else { IO.WriteLine("This would result in a modulo by zero"); } } }
/// <summary> /// 接受连接的回调函数 /// </summary> /// <param name="ar"></param> private void AcceptSocketCallback(IAsyncResult ar) { TcpListener tcpListener = ar.AsyncState as TcpListener; Socket serverSocket = null; bool bError = true;; try { serverSocket = tcpListener.EndAcceptSocket(ar); bError = false; } catch (SocketException sex) { Debug.WriteLine(string.Format("AsyncTcpServer_AcceptSocket_SocketException:{0}", sex.StackTrace)); OnError(string.Format("AsyncTcpServer_AcceptSocket_SocketException:{0}", sex.StackTrace), null); } catch (ObjectDisposedException oex) { Debug.WriteLine(string.Format("AsyncTcpServer_AcceptSocket_ObjectDisposedException:{0}", oex.StackTrace)); OnError(string.Format("AsyncTcpServer_AcceptSocket_ObjectDisposedException:{0}", oex.StackTrace), null); } catch (Exception ex) { Debug.WriteLine(string.Format("AsyncTcpServer_AcceptSocket_Exception:{0}", ex.StackTrace)); OnError(string.Format("AsyncTcpServer_AcceptSocket_Exception:{0}", ex.StackTrace), null); } Debug.WriteLine(string.Format("当前连接数:{0}", this._connectedServerSockets.Count)); try { // 接受新连接 tcpListener.BeginAcceptSocket(new AsyncCallback(this.AcceptSocketCallback), tcpListener); } catch (Exception exAcceptNew) { Debug.WriteLine(string.Format("接收新套接字时出错:{0}", exAcceptNew.StackTrace)); OnError(string.Format("接收新套接字时出错:{0}", exAcceptNew.StackTrace), null); } if (bError) { return; } TcpServerSocket socketWrapper = new TcpServerSocket(serverSocket); //////////////socketWrapper.ProtocolReceiver.OnProtocolReceived += new RoutedPropertyChangedEventHandler<protocol>(ProtocolReceiver_OnProtocolReceived); // 加入连接列表 this.AddSocketToList(socketWrapper); // 调用事件 if (this.OnAcceptSocket != null) { this.OnAcceptSocket(this, new TcpServerEventArgs(socketWrapper)); } bError = true; try { // 开始接收数据 serverSocket.BeginReceive(socketWrapper.Buffer, 0, socketWrapper.Buffer.Length, SocketFlags.None, new AsyncCallback(this.ReceiveDataCallback), socketWrapper); bError = false; } catch (SocketException sex1) { Debug.WriteLine(string.Format("AsyncTcpServer_AcceptSocket_BeginReceive_SocketException:{0}", sex1.StackTrace)); OnError(string.Format("AsyncTcpServer_AcceptSocket_BeginReceive_SocketException:{0}", sex1.StackTrace), null); } catch (ObjectDisposedException oex1) { Debug.WriteLine(string.Format("AsyncTcpServer_AcceptSocket_BeginReceive_ObjectDisposedException:{0}", oex1.StackTrace)); OnError(string.Format("AsyncTcpServer_AcceptSocket_BeginReceive_ObjectDisposedException:{0}", oex1.StackTrace), null); } catch (Exception ex1) { Debug.WriteLine(string.Format("AsyncTcpServer_AcceptSocket_BeginReceive_Exception:{0}", ex1.StackTrace)); OnError(string.Format("AsyncTcpServer_AcceptSocket_BeginReceive_Exception:{0}", ex1.StackTrace), null); } if (bError) { try { //serverSocket.Shutdown(SocketShutdown.Both); serverSocket.Close(); if (this.OnClientDisconnected != null) { this.OnClientDisconnected(this, new TcpServerEventArgs(serverSocket)); } } catch (Exception ex) { Debug.WriteLine(string.Format("关闭客户端连接出错:{0}", ex.StackTrace)); OnError(string.Format("关闭客户端连接出错:{0}", ex.StackTrace), null); } // 从列表中删除 this.RemoveSocketFromList(socketWrapper); } // 清理引用 serverSocket = null; socketWrapper = null; }
/* goodB2G1() - use badsource and goodsink by changing second privateFive==5 to privateFive!=5 */ private void GoodB2G1(HttpRequest req, HttpResponse resp) { string data; if (privateFive == 5) { data = ""; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); listener.Start(); using (TcpClient tcpConn = listener.AcceptTcpClient()) { /* read input from socket */ using (StreamReader sr = new StreamReader(tcpConn.GetStream())) { /* POTENTIAL FLAW: Read data using a listening tcp connection */ data = sr.ReadLine(); } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { if (listener != null) { try { listener.Stop(); } catch (SocketException se) { IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener"); } } } } } else { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run * but ensure data is inititialized before the Sink to avoid compiler errors */ data = null; } if (privateFive != 5) { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run */ IO.WriteLine("Benign, fixed string"); } else { /* FIX: use URLEncoder.encode to hex-encode non-alphanumerics */ if (data != null) { data = HttpUtility.UrlEncode("", Encoding.UTF8); resp.AddHeader("Location", "/author.jsp?lang=" + data); } } }
public override void Bad() { int data; /* We need to have one source outside of a for loop in order * to prevent the compiler from generating an error because * data is uninitialized */ data = int.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); listener.Start(); using (TcpClient tcpConn = listener.AcceptTcpClient()) { /* read input from socket */ using (StreamReader sr = new StreamReader(tcpConn.GetStream())) { /* POTENTIAL FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = int.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { try { if (listener != null) { listener.Stop(); } } catch (SocketException se) { IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener"); } } } for (int j = 0; j < 1; j++) { /* POTENTIAL FLAW: Zero denominator will cause an issue. An integer division will * result in an exception. */ IO.WriteLine("bad: 100/" + data + " = " + (100 / data) + "\n"); } }
public static void Connect() { server = null; try { // Set the TcpListener on port 13000. Int32 port = 13000; // TcpListener server = new TcpListener(port); server = new TcpListener(IPAddress.Loopback, port); // Start listening for client requests. server.Start(); // Buffer for reading data Byte[] bytes = new Byte[256]; String data = null; // Enter the listening loop. while (true) { Console.Write("Waiting for a connection... "); // Perform a blocking call to accept requests. // You could also use server.AcceptSocket() here. client = server.AcceptTcpClient(); Console.WriteLine("Connected!"); data = null; // Get a stream object for reading and writing NetworkStream stream = client.GetStream(); int i; // Loop to receive all the data sent by the client. while ((i = stream.Read(bytes, 0, bytes.Length)) != 0) { // Translate data bytes to a ASCII string. data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); Console.WriteLine("Received: {0}", data); Decode(data); // Process the data sent by the client. // Dont write anything back //data = data.ToUpper(); //byte[] msg = System.Text.Encoding.ASCII.GetBytes(data); //// Send back a response. //stream.Write(msg, 0, msg.Length); //Console.WriteLine("Sent: {0}", data); } //stream.Close();//Maybe? // Shutdown and end connection //client.Close(); } } catch (Exception ex) { LogExceptions(ex.ToString()); } //finally //{ // // stop listening for new clients. // //server.Stop(); //} //Console.WriteLine("\nHit enter to continue..."); //Console.Read(); }
/// <summary> /// Start a IMAP proxy instance. /// </summary> /// <param name="acceptedIPs">IP addresses to accept connections from.</param> /// <param name="localIPAddress">Local IP address to bind to.</param> /// <param name="localPort">Local port to listen on.</param> /// <param name="localEnableSsl">Whether the local server supports TLS/SSL.</param> /// <param name="remoteServerHostName">Remote server hostname to forward all IMAP messages to.</param> /// <param name="remoteServerPort">Remote server port to connect to.</param> /// <param name="remoteServerEnableSsl">Whether the remote IMAP server requires TLS/SSL.</param> /// <param name="remoteServerCredential">(Optional) Credentials to be used for all connections to the remote IMAP server. When set, this overrides any credentials passed locally.</param> /// <param name="exportDirectory">(Optional) Location where all incoming messages are saved as EML files.</param> /// <param name="logFile">File where event logs and exception information will be written.</param> /// <param name="logLevel">Proxy logging level, determining how much information is logged.</param> /// <param name="instanceId">The instance number of the proxy.</param> /// <param name="debugMode">Whether the proxy instance is running in DEBUG mode and should output full exception messages.</param> public void Start(string acceptedIPs, IPAddress localIPAddress, int localPort, bool localEnableSsl, string remoteServerHostName, int remoteServerPort, bool remoteServerEnableSsl, NetworkCredential remoteServerCredential, string exportDirectory, string logFile, LogLevel logLevel, int instanceId, bool debugMode) { // Create the log writer. string logFileName = ""; if (!string.IsNullOrEmpty(logFile)) { logFileName = ProxyFunctions.GetLogFileName(logFile, instanceId, localIPAddress.ToString(), remoteServerHostName, localPort, remoteServerPort); LogWriter = new StreamWriter(logFileName, true, Encoding.UTF8, Constants.SMALLBUFFERSIZE); LogWriter.AutoFlush = true; LogLevel = logLevel; } // Make sure the remote server isn't an infinite loop back to this server. string fqdn = Functions.GetLocalFQDN(); if (remoteServerHostName.ToUpper() == fqdn.ToUpper() && remoteServerPort == localPort) { ProxyFunctions.Log(LogWriter, SessionId, "Cannot start service because the remote server host name {" + remoteServerHostName + "} and port {" + remoteServerPort.ToString() + "} is the same as this proxy, which would cause an infinite loop.", Proxy.LogLevel.Critical, LogLevel); return; } IPHostEntry hostEntry = Dns.GetHostEntry(Dns.GetHostName()); foreach (IPAddress hostIP in hostEntry.AddressList) { if (remoteServerHostName == hostIP.ToString() && remoteServerPort == localPort) { ProxyFunctions.Log(LogWriter, SessionId, "Cannot start service because the remote server hostname {" + remoteServerHostName + "} and port {" + remoteServerPort.ToString() + "} is the same as this proxy, which would cause an infinite loop.", Proxy.LogLevel.Critical, LogLevel); return; } } ProxyFunctions.Log(LogWriter, SessionId, "Starting service.", Proxy.LogLevel.Information, LogLevel); // Attempt to start up to 3 times in case another service using the port is shutting down. int startAttempts = 0; while (startAttempts < 3) { startAttempts++; // If we've failed to start once, wait an extra 10 seconds. if (startAttempts > 1) { ProxyFunctions.Log(LogWriter, SessionId, "Attempting to start for the " + (startAttempts == 2 ? "2nd" : "3rd") + " time.", Proxy.LogLevel.Information, LogLevel); Thread.Sleep(10000 * startAttempts); } try { X509Certificate serverCertificate = null; // Generate a unique session ID for logging. SessionId = Guid.NewGuid().ToString(); ConnectionId = 0; // If local SSL is supported via STARTTLS, ensure we have a valid server certificate. if (localEnableSsl) { serverCertificate = CertHelper.GetCertificateBySubjectName(StoreLocation.LocalMachine, fqdn); // In case the service as running as the current user, check the Current User certificate store as well. if (serverCertificate == null) { serverCertificate = CertHelper.GetCertificateBySubjectName(StoreLocation.CurrentUser, fqdn); } // If no certificate was found, generate a self-signed certificate. if (serverCertificate == null) { ProxyFunctions.Log(LogWriter, SessionId, "No signing certificate found, so generating new certificate.", Proxy.LogLevel.Warning, LogLevel); List <string> oids = new List <string>(); oids.Add("1.3.6.1.5.5.7.3.1"); // Server Authentication. // Generate the certificate with a duration of 10 years, 4096-bits, and a key usage of server authentication. serverCertificate = CertHelper.CreateSelfSignedCertificate(fqdn, fqdn, StoreLocation.LocalMachine, true, 4096, 10, oids); ProxyFunctions.Log(LogWriter, SessionId, "Certificate generated with Serial Number {" + serverCertificate.GetSerialNumberString() + "}.", Proxy.LogLevel.Information, LogLevel); } } Listener = new TcpListener(localIPAddress, localPort); Listener.Start(); ProxyFunctions.Log(LogWriter, SessionId, "Service started.", Proxy.LogLevel.Information, LogLevel); ProxyFunctions.Log(LogWriter, SessionId, "Listening on address {" + localIPAddress.ToString() + "}, port {" + localPort + "}.", Proxy.LogLevel.Information, LogLevel); Started = true; // Accept client requests, forking each into its own thread. while (Started) { TcpClient client = Listener.AcceptTcpClient(); string newLogFileName = ProxyFunctions.GetLogFileName(logFile, instanceId, localIPAddress.ToString(), remoteServerHostName, localPort, remoteServerPort); if (newLogFileName != logFileName) { LogWriter.Close(); LogWriter = new StreamWriter(newLogFileName, true, Encoding.UTF8, Constants.SMALLBUFFERSIZE); LogWriter.AutoFlush = true; } // Prepare the arguments for our new thread. ImapProxyConnectionArguments arguments = new ImapProxyConnectionArguments(); arguments.AcceptedIPs = acceptedIPs; arguments.TcpClient = client; arguments.Certificate = serverCertificate; arguments.ExportDirectory = exportDirectory; arguments.LocalIpAddress = localIPAddress; arguments.LocalPort = localPort; arguments.LocalEnableSsl = localEnableSsl; arguments.RemoteServerHostName = remoteServerHostName; arguments.RemoteServerPort = remoteServerPort; arguments.RemoteServerEnableSsl = remoteServerEnableSsl; arguments.RemoteServerCredential = remoteServerCredential; // Increment the connection counter; arguments.ConnectionId = (unchecked (++ConnectionId)).ToString(); arguments.InstanceId = instanceId; arguments.DebugMode = debugMode; // Fork the thread and continue listening for new connections. Thread processThread = new Thread(new ParameterizedThreadStart(ProcessConnection)); processThread.Name = "OpaqueMail IMAP Proxy Connection"; processThread.Start(arguments); } return; } catch (Exception ex) { if (debugMode || System.Diagnostics.Debugger.IsAttached) { ProxyFunctions.Log(LogWriter, SessionId, "Exception when starting proxy: " + ex.ToString(), Proxy.LogLevel.Critical, LogLevel); } else { ProxyFunctions.Log(LogWriter, SessionId, "Exception when starting proxy: " + ex.Message, Proxy.LogLevel.Critical, LogLevel); } } } }
static void Main(string[] args) { WebServer www = new WebServer(80, "c:\\www", "index.htm"); Console.WriteLine("WebServer wird gestartet..."); string ipAddress = "127.0.0.1"; IPAddress ip = IPAddress.Parse(ipAddress); IPEndPoint ep = new IPEndPoint(ip, www.Port); TcpListener listen = null; // Datenpuffer Byte[] bytes = null; int i; try { listen = new TcpListener(ep); listen.Start(); } catch (Exception) { throw; } do { Console.WriteLine("Warte auf eine Verbindung..."); TcpClient client = listen.AcceptTcpClient(); Console.WriteLine("Verbindung hergestellt!"); string Data = null; NetworkStream stream = client.GetStream(); bytes = new Byte[client.ReceiveBufferSize]; Console.WriteLine("Client-Anfrage..."); // Lesen der Daten i = stream.Read(bytes, 0, bytes.Length); if (i > 0) { Data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); Console.WriteLine(Data); } // Tokens string[] words = Data.Split(' '); if (words[0] == "GET") { if (words[1].EndsWith("/")) { words[1] = words[1] + www.DefaultFile; } // Dokument an Client senden FileStream file = null; try { file = new FileStream(www.DocumentRoot + words[1], FileMode.Open); byte[] readBuffer = new byte[4096]; int r = 0; int offset = 0; while ((r = file.Read(readBuffer, offset, readBuffer.Length)) > 0) { stream.Write(readBuffer, 0, r); } } catch (FileNotFoundException) { string errMsg = "<html><head><title>Fehler</title></head>" + "<body><h2>404 Nicht gefunden</h2></body></html>"; ASCIIEncoding enc = new ASCIIEncoding(); stream.Write(enc.GetBytes(errMsg), 0, errMsg.Length); } catch (Exception) { throw; } finally { if (file != null) { file.Close(); } } } else { Console.WriteLine("FEHLER 400 : BAD REQUEST"); } client.Close(); i = 0; } while (true); }
private static void Main() { Console.Title = "Zteam Studio GameServer"; LogFactory.OnWrite += Log.LogFactory_ConsoleWrite; start: try { Settings.Initialize(); AutoRestartTIme = Settings.GetInt("GameServer/AutoRestartTime"); LogFactory.GetLog("Main").LogInfo("reinicializaçao automatica do servidor é definido como {0} segundos.", Server.AutoRestartTIme); UDPRelayIP = Settings.GetString("GameServer/UDPRelayIP"); UDPRelayPort = Settings.GetShort("GameServer/UDPRelayPort"); TCPRelayIP = Settings.GetString("GameServer/TCPRelayIP"); TCPRelayPort = Settings.GetShort("GameServer/TCPRelayPort"); MsgServerIP = Settings.GetString("GameServer/MsgServerIP"); MsgServerPort = Settings.GetShort("GameServer/MsgServerPort"); TSingleton <ChannelManager> .Instance.AddChannel("대전", 2000, 0); TSingleton <ChannelManager> .Instance.AddChannel("던전", 2000, 0); Clients = new GCClients(); LogFactory.GetLog("Main").LogInfo("Criando lista de clientes objetos"); Handlers = new HandlerStore <GCClient>(); Handlers.Cache(); Database.Test(); Database.Analyze(); LogFactory.GetLog("Shop").LogInfo("Carregando Items da DB"); Shop shop = new Shop(); shop.LoadShop(); LogFactory.GetLog("Shop").LogInfo("Items Carregads, Total: " + shop.goodsIttems.Length); LogFactory.GetLog("Hero Dungeon").LogInfo("Carregando Lista De Hero!"); GCCommon MyCommon = new GCCommon(); MyCommon.LoadHero(); LogFactory.GetLog("Hero Dungeon").LogInfo("Hero Dungeon Carreda!,Total: " + MyCommon.herodungeon.Length); RemoteEndPoint = new IPEndPoint(Settings.GetIPAddress("GameServer/ExternalIP"), Settings.GetInt("GameServer/Port")); Listener = new TcpListener(IPAddress.Any, Server.RemoteEndPoint.Port); Listener.Start(); LogFactory.GetLog("Main").LogInfo("conexao socket iniciada. porta: {0}.", Server.Listener.LocalEndpoint); User.StatusOnline(null, null, 0, 2); IsAlive = true; } catch (Exception e) { LogFactory.GetLog("MAIN").LogFatal(e); } if (Server.IsAlive) { LogFactory.GetLog("Main").LogInfo("o servidor foi aberto com sucesso. a identificaçao do segmento : {0}.", Thread.CurrentThread.ManagedThreadId); } else { LogFactory.GetLog("Main").LogInfo("o servidor nao foi iniciado com sucesso."); } while (Server.IsAlive) { Server.AcceptDone.Reset(); Server.Listener.BeginAcceptSocket(new AsyncCallback(Server.OnAcceptSocket), null); Server.AcceptDone.WaitOne(); } GCClient[] remainingClients = Server.Clients.ToArray(); foreach (GCClient client in remainingClients) { client.Close(); } Server.Dispose(); LogFactory.GetLog("Main").LogWarning("Error "); if (Server.AutoRestartTIme > 0) { Thread.Sleep(Server.AutoRestartTIme * 1000); goto start; } else { Console.Read(); } { return; } }
public HttpServer() { this.tcpListener = new TcpListener(IPAddress.Parse("127.0.0.1"), 80); }
// the listener thread's listen function private void Listen(int port, int maxConnections) { // absolutely must wrap with try/catch, otherwise thread // exceptions are silent try { // start listener // (NoDelay disables nagle algorithm. lowers CPU% and latency) _listener = new TcpListener(new IPEndPoint(IPAddress.Any, port)); _listener.Server.NoDelay = true; _listener.Start(); Logger.Log("Server: listening port=" + port + " max=" + maxConnections); // keep accepting new clients while (true) { // wait and accept new client // note: 'using' sucks here because it will try to // dispose after thread was started but we still need it // in the thread TcpClient client = _listener.AcceptTcpClient(); // are more connections allowed? if (_clients.Count < maxConnections) { // generate the next connection id (thread safely) int connectionId = NextConnectionId(); // spawn a thread for each client to listen to his // messages Thread thread = new Thread(() => { // add to dict immediately _clients.Add(connectionId, client); // run the receive loop ReceiveLoop(connectionId, client, MessageQueue); // remove client from clients dict afterwards _clients.Remove(connectionId); }); thread.IsBackground = true; thread.Start(); } // connection limit reached. disconnect the client and show // a small log message so we know why it happened. // note: no extra Sleep because Accept is blocking anyway else { client.Close(); Logger.Log("Server too full, disconnected a client"); } } } catch (ThreadAbortException exception) { // UnityEditor causes AbortException if thread is still // running when we press Play again next time. that's okay. Logger.Log("Server thread aborted. That's okay. " + exception); } catch (SocketException exception) { // calling StopServer will interrupt this thread with a // 'SocketException: interrupted'. that's okay. Logger.Log("Server Thread stopped. That's okay. " + exception); } catch (Exception exception) { // something went wrong. probably important. Logger.LogError("Server Exception: " + exception); } }
public Server(int Port) { ipAddr = new IPEndPoint(IPAddress.Parse(GetLocalIP), Port); listener = new TcpListener(ipAddr); }
public override void Bad() { int data; if (privateFive == 5) { data = int.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); listener.Start(); using (TcpClient tcpConn = listener.AcceptTcpClient()) { /* read input from socket */ using (StreamReader sr = new StreamReader(tcpConn.GetStream())) { /* POTENTIAL FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = int.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { try { if (listener != null) { listener.Stop(); } } catch (SocketException se) { IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener"); } } } } else { /* INCIDENTAL: CWE 561 Dead Code, the code below will never run * but ensure data is inititialized before the Sink to avoid compiler errors */ data = 0; } if (privateFive == 5) { /* POTENTIAL FLAW: Zero modulus will cause an issue. An integer division will * result in an exception. */ IO.WriteLine("100%" + data + " = " + (100 % data) + "\n"); } }
public SUTControlListener() { listenServer = new TcpListener(GetLocalIP(), listenPort); processThread = new Thread(new ThreadStart(ProcessControlCommandThread)); }
public ThreadInPool(TcpListener listener, ILogger logger, Func <string, string> workload) { this.listener = listener; this.logger = logger; this.workload = workload; }
public Listener(IPAddress ip, int port) { _listener = new TcpListener(ip, port); }
static void Main(string[] args) { TcpListener server = null; try { // Set the TcpListener on port 13000. Int32 port = 13000; IPAddress localAddr = IPAddress.Parse("0.0.0.0"); // TcpListener server = new TcpListener(port); server = new TcpListener(localAddr, port); // Start listening for client requests. server.Start(); // Buffer for reading data Byte[] bytes = new Byte[256]; String data = null; // Enter the listening loop. while (true) { Console.Write("Waiting for a connection... "); // Perform a blocking call to accept requests. // You could also user server.AcceptSocket() here. TcpClient client = server.AcceptTcpClient(); Console.WriteLine("Connected!"); data = null; // Get a stream object for reading and writing NetworkStream stream = client.GetStream(); int i; // Loop to receive all the data sent by the client. while ((i = stream.Read(bytes, 0, bytes.Length)) != 0) { // Translate data bytes to a ASCII string. data = System.Text.Encoding.ASCII.GetString(bytes, 0, i); Console.WriteLine("Received: {0}", data); // Process the data sent by the client. data = data.ToUpper(); byte[] msg = System.Text.Encoding.ASCII.GetBytes(data); // Send back a response. //stream.Write(msg, 0, msg.Length); //Console.WriteLine("Sent: {0}", data); } // Shutdown and end connection client.Close(); } } catch (SocketException e) { Console.WriteLine("SocketException: {0}", e); } finally { // Stop listening for new clients. server.Stop(); } Console.WriteLine("\nHit enter to continue..."); Console.Read(); }
public override void Bad() { float data; data = float.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; TcpClient tcpConn = null; StreamReader sr = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); tcpConn = listener.AcceptTcpClient(); /* read input from socket */ sr = new StreamReader(tcpConn.GetStream()); /* FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = float.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { /* Close stream reading objects */ try { if (sr != null) { sr.Close(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing StreamReader"); } /* Close socket objects */ try { if (tcpConn != null) { tcpConn.Close(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpClient"); } try { if (listener != null) { listener.Stop(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpListener"); } } } CWE197_Numeric_Truncation_Error__float_listen_tcp_to_byte_53b.BadSink(data); }
static void Main(string[] args) { int port = 8080; TcpListener listener = new TcpListener(IPAddress.Any, port); try { listener.Start(); while (true) { Console.WriteLine("Listening..."); TcpClient client = listener.AcceptTcpClient(); StreamReader readStream = new StreamReader(client.GetStream()); StreamWriter writeStream = new StreamWriter(client.GetStream()); string message = ""; try { string request = readStream.ReadLine(); Console.WriteLine(request); string[] tokens = request.Split(' '); string page = tokens[1]; using (writeStream) { if (page == "/") { writeStream.WriteLine("HTTP/1.0 200 OK\n"); message = "<!doctype html> <html> <head> <title>Home Page</title> </head> <body> <h1>Welcome to our test page.</h1> <h4>You can check the server information <a href=\"/info\">here</a></h4> </body> </html>"; writeStream.Write(message); } else if (page == "/info") { writeStream.WriteLine("HTTP/1.0 200 OK\n"); var ci = new CultureInfo("en-US"); message = string.Format("<!doctype html> <html> <head> <title>Info Page</title> </head> <body> <h2>Current Time: {0}</h2> <h2>Logical Processors: {1}</h2><h4>Back to the <a href=\"/\">homepage</a></h4> </body> </html>", DateTime.Now.ToString("dd MMM yyyy HH:mm:ss", ci), Environment.ProcessorCount); writeStream.Write(message); } else { writeStream.WriteLine("HTTP/1.0 200 OK\n"); message = string.Format("<!doctype html> <html> <head> <title>Error Page</title> </head> <body> <h2 style=\"color: red\">Error! Try going to the <a href=\" / \">home page</a></h2> </body> </html>"); writeStream.Write(message); } } } catch (Exception e) { using (writeStream) { writeStream.WriteLine("HTTP/1.0 404 OK\n"); Console.WriteLine($"Exception: {e.Message}"); } } Console.WriteLine("Response sent."); } } catch (WebException exception) { Console.WriteLine(exception.Status); } }
public Server(int port, ServerRoutingTable serverRoutingTable) { this.Port = port; this.Listener = new TcpListener(IPAddress.Parse(LocalHostIpAddress), port); this.ServerRoutingTable = serverRoutingTable; }
public static void Main(string[] args) { TcpListener server = null; try { // Set the TcpListener on port 13000. IPAddress localAddr = IPAddress.Parse(args[0]); Int32 port = Convert.ToInt32(args[1]); // TcpListener server = new TcpListener(port); server = new TcpListener(localAddr, port); // Start listening for client requests. server.Start(); // String data = null; // Enter the listening loop. while (true) { Console.Write("Waiting for a connection... "); TcpClient client1 = server.AcceptTcpClient(); Console.WriteLine("Connected!"); NetworkStream stream1 = client1.GetStream(); // StreamReader reader1 = new StreamReader(stream1); // StreamWriter writer1 = new StreamWriter(stream1); Console.Write("Waiting for a connection... "); TcpClient client2 = server.AcceptTcpClient(); Console.WriteLine("Connected!"); NetworkStream stream2 = client2.GetStream(); // StreamReader reader2 = new StreamReader(stream2); // StreamWriter writer2 = new StreamWriter(stream2); TicTac tictac = new TicTac(); tictac.Play(stream1, stream2); // data = null; ///////////// Get a stream object for reading and writing // NetworkStream stream1 = client1.GetStream(); // StreamReader reader1 = new StreamReader(stream1); // StreamWriter writer1 = new StreamWriter(stream1); // NetworkStream stream2 = client2.GetStream(); // StreamReader reader2 = new StreamReader(stream2); // StreamWriter writer2 = new StreamWriter(stream2); // writer.AutoFlush = true; // Loop to receive all the data sent by the client. // while ((data = reader.ReadLine()) != null) // { // Console.WriteLine("Received: {0}", data); // // Process the data sent by the client. // String response = data.ToUpper(); // // Send back a response. // writer.WriteLine(response); // writer.Flush(); // Console.WriteLine("Sent: {0}", response); // } // Shutdown and end connection client1.Close(); } } catch (SocketException e) { Console.WriteLine("SocketException: {0}", e); } finally { // Stop listening for new clients. server.Stop(); } Console.WriteLine("\nHit enter to continue..."); Console.Read(); }
/* uses badsource and badsink - see how tools report flaws that don't always occur */ public override void Bad() { float data; if (IO.StaticReturnsTrueOrFalse()) { data = float.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; TcpClient tcpConn = null; StreamReader sr = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); tcpConn = listener.AcceptTcpClient(); /* read input from socket */ sr = new StreamReader(tcpConn.GetStream()); /* FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = float.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { /* Close stream reading objects */ try { if (sr != null) { sr.Close(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing StreamReader"); } /* Close socket objects */ try { if (tcpConn != null) { tcpConn.Close(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpClient"); } try { if (listener != null) { listener.Stop(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpListener"); } } } } else { /* FIX: Use a hardcoded number that won't cause underflow, overflow, divide by zero, or loss-of-precision issues */ data = 2; } { /* POTENTIAL FLAW: Convert data to a int, possibly causing a truncation error */ IO.WriteLine((int)data); } }
// Main thread for sending telegrams private void SendThreading() { TelegramACK telAck = null; try { if (SimulateMFCS) { SendListener = new TcpListener(SendIPEndPoint); Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThreading", SendIPEndPoint.ToString()); SendListener.Start(); } lock (_lockSendTelegram) { SendTelegrams.RemoveAll(p => p.CommSendStatus >= Telegram.CommSendStatusEnum.Ack); } LastSendTime = DateTime.Now; while (Thread.CurrentThread.ThreadState == ThreadState.Background) { try { Telegram tel = null; lock (_lockSendTelegram) tel = SendTelegrams.FirstOrDefault(prop => prop.CommSendStatus < Telegram.CommSendStatusEnum.Ack); if (DateTime.Now - LastSendTime > SendTimeOut) { InitSendSocket(); if (tel != null) { tel.CommSendStatus = Telegram.CommSendStatusEnum.None; } LastSendTime = DateTime.Now; Retry = 0; Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThread", "Send timeout, SendSocket reinitialized!"); } else if (DateTime.Now - LastSendTime > KeepALifeTime && tel == null) { Telegram tRes = null; lock (_lockSendTelegram) tRes = SendTelegrams.FirstOrDefault(prop => prop.CommSendStatus < Telegram.CommSendStatusEnum.Ack); if (tRes == null) { if (KeepALifeTelegram != null) { Telegram t = Activator.CreateInstance(KeepALifeTelegram.GetType()) as Telegram; t.Sender = MFCS_ID; t.Receiver = PLC_ID; t.Build(); AddSendTelegram(t); Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThread", String.Format("Adding KeepALife telegram")); } } } else if (!SendSocket.Connected) { InitSendSocket(); ConnectSendPartner(); } else if (tel != null) { switch (tel.CommSendStatus) { case (Telegram.CommSendStatusEnum.None): tel.Sequence = Sequence; tel.Build(); // Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThread", String.Format("Start sending {0}", tel.ToString())); SendSocket.Send(tel.ByteBuffer, tel.Length, SocketFlags.None); Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThread", String.Format("Sended {0}", tel.ToString())); tel.CommSendStatus = Telegram.CommSendStatusEnum.WaitACK; telAck = new TelegramACK(); SendTime = DateTime.Now; break; case (Telegram.CommSendStatusEnum.WaitACK): int numRead = 0; do { numRead += SendSocket.Receive(telAck.ByteBuffer, numRead, telAck.ByteBuffer.Length - numRead, SocketFlags.None); } while (numRead < telAck.ByteBuffer.Length); telAck.ReadBuffer(); Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThread", String.Format("Received ACK {0}", telAck.ToString())); if (telAck.Validate() && telAck.Sequence == tel.Sequence) { tel.CommSendStatus = Telegram.CommSendStatusEnum.Ack; LastSendTime = DateTime.Now; Retry = 0; if (Sequence < 99) { Sequence++; } else { Sequence = 0; } Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThreading", String.Format("Send Finished : {0}", tel.ToString())); NotifySend(tel); } else { // tel.CommSendStatus = Telegram.CommSendStatusEnum.None; Retry++; Log.AddLog(Log.Severity.EVENT, Name, "Communication.SendThreading", String.Format("Retry increased - {0}", Retry)); } break; default: break; } } else { Thread.Sleep(100); } } catch (SocketException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.SendThread::SocketException", ex.Message); Thread.Sleep(1000); } } catch (TelegramException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.SendThread::TelegramException", ex.Message); Thread.Sleep(1000); } catch (ThreadAbortException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.RcvThreading::Communication", ex.Message); return; } catch (CommunicationException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.SendThread::CommunicationException", ex.Message); Thread.Sleep(1000); } }
public void StartListening() { try { this.listener = new TcpListener(IPAddress.Any, this.Port); this.Prefix = new Uri(string.Format(CultureInfo.InvariantCulture, "http://localhost:{0}", this.Port)); this.dispatcher = new UriDispatchTables(new Uri(this.Prefix, UrnPrefix)); this.executorDispatcher = new CommandExecutorDispatchTable(); // Start listening for client requests. this.listener.Start(); // Enter the listening loop while (true) { Logger.Debug("Waiting for a connection..."); // Perform a blocking call to accept requests. var client = this.listener.AcceptTcpClient(); // Get a stream object for reading and writing using (var stream = client.GetStream()) { var acceptedRequest = HttpRequest.ReadFromStreamWithoutClosing(stream); if (string.IsNullOrWhiteSpace(acceptedRequest.StartingLine)) { Logger.Warn("ACCEPTED EMPTY REQUEST"); } else { Logger.Debug("ACCEPTED REQUEST {0}", acceptedRequest.StartingLine); var response = this.HandleRequest(acceptedRequest); using (var writer = new StreamWriter(stream)) { try { writer.Write(response); writer.Flush(); } catch (IOException ex) { Logger.Error("Error occured while writing response: {0}", ex); } } } // Shutdown and end connection } client.Close(); Logger.Debug("Client closed\n"); } } catch (SocketException ex) { Logger.Error("SocketException occurred while trying to start listner: {0}", ex); throw; } catch (ArgumentException ex) { Logger.Error("ArgumentException occurred while trying to start listner: {0}", ex); throw; } finally { // Stop listening for new clients. this.listener.Stop(); } }
/* goodB2G() - use badsource and goodsink*/ private void GoodB2G() { int data; data = int.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); listener.Start(); using (TcpClient tcpConn = listener.AcceptTcpClient()) { /* read input from socket */ using (StreamReader sr = new StreamReader(tcpConn.GetStream())) { /* POTENTIAL FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = int.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { try { if (listener != null) { listener.Stop(); } } catch (SocketException se) { IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener"); } } } for (int k = 0; k < 1; k++) { /* FIX: test for a zero denominator */ if (data != 0) { IO.WriteLine("100/" + data + " = " + (100 / data) + "\n"); } else { IO.WriteLine("This would result in a divide by zero"); } } }
private void InitSocket() { try { tbxLocalIpAddress.Text = Regex.Replace(tbxLocalIpAddress.Text, @"[^0-9].[^0-9].[^0-9].[^0-9]", ""); tbxPort.Text = Regex.Replace(tbxPort.Text, @"[^0-9]", ""); if (tbxLocalIpAddress.Text == "" || tbxPort.Text == "") { MessageBox.Show("Local IP Address 또는 Port 번호가 올바르지 않습니다."); throw new Exception(); } TcpListner = new TcpListener(IPAddress.Parse(tbxLocalIpAddress.Text.Trim()), Int32.Parse(tbxPort.Text)); TcpClient = default(TcpClient); TcpListner.Start(); DisplayText(">> server Started"); while (true) { try { TcpClient = TcpListner.AcceptTcpClient(); NetworkStream stream = TcpClient.GetStream(); stream = TcpClient.GetStream(); byte[] sizeBuf = new byte[TcpClient.ReceiveBufferSize]; stream.Read(sizeBuf, 0, (int)TcpClient.ReceiveBufferSize); int size = BitConverter.ToInt32(sizeBuf, 0); MemoryStream memoryStream = new MemoryStream(); while (size > 0) { byte[] buffer; if (size < TcpClient.ReceiveBufferSize) { buffer = new byte[size]; } else { buffer = new byte[TcpClient.ReceiveBufferSize]; } int rec = stream.Read(buffer, 0, buffer.Length); size -= rec; memoryStream.Write(buffer, 0, buffer.Length); } memoryStream.Close(); byte[] data = memoryStream.ToArray(); memoryStream.Dispose(); string channel = Encoding.UTF8.GetString(data); this.Invoke(new DeligateGetClientIP(GetClientIP), channel); ClientList.Add(TcpClient, channel); SendMessageAll(ClientIP + "/ 님이 연결되었습니다.", channel, true); HandleClient handle = new HandleClient(); handle.OnReceived += new HandleClient.MessageDisplayHandler(OnReceived); handle.OnDisconnected += new HandleClient.DisconnectedHandler(OnDisconnected); handle.StartClient(TcpClient, ClientList); } catch { throw new SocketException(); } } } catch (SocketException ex) { this.Invoke(new DeligateDisconnect(Disconnect)); ServerEvent.ErrorLog("InitSocket", ex.Message); } catch (Exception ex) { ServerEvent.ErrorLog("InitSocket", ex.Message); } finally { this.Invoke(new DeligateButtonChange(ButtonStatusChange)); } }
public Task Run() { Core.Instance.Log.InfoFormat("Starting EnhancedRestoreChunkProtocol: {0}", _fileChunk); return(Task.Factory.StartNew(() => { Core.Instance.MCChannel.Send(new GetChunkMessage(_fileChunk)); var src1 = Core.Instance.MDRChannel.Received .Where(message => message.MessageType == MessageType.Chunk) .Cast <ChunkMessage>() .Where(message => message.ChunkNo == _fileChunk.ChunkNo && message.FileId == _fileChunk.FileId) .Cast <Message>(); var src2 = Core.Instance.MDRChannel.Received .Where(message => message.MessageType == MessageType.ACK) .Cast <ACKMessage>() .Where(message => message.ChunkNo == _fileChunk.ChunkNo && message.FileId == _fileChunk.FileId) .Cast <Message>(); Message msg; try { // wait for response msg = src1.Merge(src2).Timeout(TimeSpan.FromMilliseconds(Timeout)) .Next().First(); } catch (TimeoutException) { Core.Instance.Log.ErrorFormat("EnhancedRestoreChunkProtocol: Could not fetch {0} from the network (timeout).", _fileChunk); return; } if (msg.MessageType == MessageType.Chunk) // same behaviour as the regular protocol { Message = msg as ChunkMessage; return; } var ackMessage = msg as ACKMessage; if (ackMessage == null) { Core.Instance.Log.ErrorFormat("EnhancedRestoreChunkProtocol: could not cast message {0} to ACK", msg); return; } var listener = new TcpListener(IPAddress.Any, 0); listener.Start(); Core.Instance.MCChannel.Send(new ConnInfoMessage(_fileChunk, ((IPEndPoint)listener.LocalEndpoint).Port, ackMessage.RemoteEndPoint.Address)); var clientTask = listener.AcceptTcpClientAsync(); if (!clientTask.Wait(Timeout)) { Core.Instance.Log.Error("EnhancedRestoreChunkProtocol: listener.AcceptTcpClientAsync timed out"); return; } Core.Instance.Log.Info("EnhancedRestoreChunkProtocol: TcpClient accepted"); try { var stream = clientTask.Result.GetStream(); var bytes = new byte[Core.Instance.Config.ChunkSize]; var bytesRead = stream.Read(bytes, 0, bytes.Length); Message = new ChunkMessage(_fileChunk, bytes.Take(bytesRead).ToArray()); clientTask.Result.Close(); } catch (Exception) { Core.Instance.Log.Error("EnhancedRestoreChunkProtocol: error receiving chunk"); } Core.Instance.Log.Info("EnhancedRestoreChunkProtocol: chunk was received with success"); })); }
// Main thread for receiving telegrams private void RcvThreading() { try { if (SimulateMFCS) { RcvListener = new TcpListener(RcvIPEndPoint); Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", RcvIPEndPoint.ToString()); RcvListener.Start(); } LastReceiveTime = DateTime.Now; while (Thread.CurrentThread.ThreadState == ThreadState.Background) { try { RcvTelegrams.RemoveAll(p => p.CommRcvStatus >= Telegram.CommRcvStatusEnum.NotifyDone); if (DateTime.Now - LastReceiveTime > RcvTimeOut) { InitRcvSocket(); LastReceiveTime = DateTime.Now; Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", "Timeout receiving"); } else if (DateTime.Now - LastNotifyTime > RefreshTime) { LastNotifyTime = DateTime.Now; Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", "Refresh() is called"); OnRefresh.ForEach(prop => prop?.Invoke()); } else if (!RcvSocket.Connected) { InitRcvSocket(); ConnectRcvPartner(); } else { if (RcvSocket.Available == 0) { Thread.Sleep(1); } else { Telegram tel = new TelegramOnlyHeader(); int numRead = 0; do { numRead += RcvSocket.Receive(tel.ByteBuffer, numRead, tel.ByteBuffer.Length - numRead, SocketFlags.None); } while (numRead < tel.ByteBuffer.Length); // Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", String.Format("Received {0} bytes", numRead)); tel.ReadBuffer(); tel.Validate(false); Telegram tel1 = Activator.CreateInstance(AllTelegrams[tel.TelType].GetType()) as Telegram; tel.ByteBuffer.CopyTo(tel1.ByteBuffer, 0); if (tel1.DesignLength() - tel.DesignLength() > 0 && tel.TelCode == 0) { numRead = 0; do { numRead += RcvSocket.Receive(tel1.ByteBuffer, tel.DesignLength() + numRead, tel1.DesignLength() - tel.DesignLength() - numRead, SocketFlags.None); } while (numRead < tel1.DesignLength() - tel.DesignLength()); // Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", String.Format("Received {0} bytes", numRead)); } tel1.ReadBuffer(); tel1.Validate(); NotifyRcv(tel1); TelegramACK telACK = new TelegramACK(); telACK.Sequence = tel.Sequence; telACK.TelCode = (System.UInt16) 0xFFFF; telACK.TelType = tel.TelType; telACK.Sender = tel.Receiver; telACK.Receiver = tel.Sender; telACK.Build(); RcvSocket.Send(telACK.ByteBuffer); Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", String.Format("ACK sended {0}", telACK.ToString())); tel1.CommRcvStatus = Telegram.CommRcvStatusEnum.Ack; RcvTelegrams.Add(tel1); LastReceiveTime = DateTime.Now; LastNotifyTime = DateTime.Now; Log.AddLog(Log.Severity.EVENT, Name, "Communication.RcvThreading", String.Format("Received finished : {0}", tel1.ToString())); } } } catch (SocketException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.RcvThreading::Socket", ex.Message); Thread.Sleep(1000); } catch (TelegramException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.RcvThreading::Telegram", ex.Message); Thread.Sleep(1000); } catch (KeyNotFoundException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.RcvThreading::KeyNotFound", ex.Message); Thread.Sleep(1000); } catch (CommunicationException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.RcvThreading::Communication", ex.Message); Thread.Sleep(1000); } catch (ThreadAbortException ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.RcvThreading::Communication", ex.Message); return; } catch (Exception ex) { Log.AddLog(Log.Severity.EXCEPTION, Name, "Communication.SendThread::unknown", ex.Message); Thread.Sleep(1000); } } } finally { RcvSocket.Close(); RcvSocket.Dispose(); SendSocket.Close(); SendSocket.Dispose(); } }
private static double BadSource() { double data; data = double.MinValue; /* Initialize data */ /* Read data using a listening tcp connection */ { TcpListener listener = null; TcpClient tcpConn = null; StreamReader sr = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); tcpConn = listener.AcceptTcpClient(); /* read input from socket */ sr = new StreamReader(tcpConn.GetStream()); /* FLAW: Read data using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { data = double.Parse(stringNumber.Trim()); } catch (FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing data from string"); } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { /* Close stream reading objects */ try { if (sr != null) { sr.Close(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing StreamReader"); } /* Close socket objects */ try { if (tcpConn != null) { tcpConn.Close(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpClient"); } try { if (listener != null) { listener.Stop(); } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error closing TcpListener"); } } } return(data); }
public override void Bad() { int count; while (true) { count = int.MinValue; /* Initialize count */ /* Read data using a listening tcp connection */ { TcpListener listener = null; /* Read data using a listening tcp connection */ try { listener = new TcpListener(IPAddress.Parse("10.10.1.10"), 39543); listener.Start(); using (TcpClient tcpConn = listener.AcceptTcpClient()) { /* read input from socket */ using (StreamReader sr = new StreamReader(tcpConn.GetStream())) { /* POTENTIAL FLAW: Read count using a listening tcp connection */ string stringNumber = sr.ReadLine(); if (stringNumber != null) // avoid NPD incidental warnings { try { count = int.Parse(stringNumber.Trim()); } catch(FormatException exceptNumberFormat) { IO.Logger.Log(NLog.LogLevel.Warn, exceptNumberFormat, "Number format exception parsing count from string"); } } } } } catch (IOException exceptIO) { IO.Logger.Log(NLog.LogLevel.Warn, exceptIO, "Error with stream reading"); } finally { try { if (listener != null) { listener.Stop(); } } catch(SocketException se) { IO.Logger.Log(NLog.LogLevel.Warn, se, "Error closing TcpListener"); } } } break; } while (true) { int i = 0; /* POTENTIAL FLAW: For loop using count as the loop variant and no validation */ for (i = 0; i < count; i++) { IO.WriteLine("Hello"); } break; } }
public void Start() { m_tcpListener = new TcpListener(IPAddress.Loopback, m_port); m_tcpListener.Start(); UnityEngine.Debug.Log("Listening for python interpreter commands on port " + m_port); m_tcpListener.BeginAcceptTcpClient(HandleClientComm, null); }
/// <summary> /// Constructor /// </summary> public ListenerSocket() { // Init loadBalancerSocket = new TcpClient(); // Connect to the loadbalancer Console.Write("Enter the loadbalancer ip: "); // Prompt loadBalancerSocket.Connect(IPAddress.Parse(Console.ReadLine()), int.Parse(Server.Properties.Resources.LoadBalancerPort)); Logger.ShowMessage( String.Format("Connected to loadbalancer on: {0}:{1} and {2}:{3}", ((IPEndPoint)loadBalancerSocket.Client.LocalEndPoint).Address, ((IPEndPoint)loadBalancerSocket.Client.LocalEndPoint).Port, ((IPEndPoint)loadBalancerSocket.Client.RemoteEndPoint).Address, ((IPEndPoint)loadBalancerSocket.Client.RemoteEndPoint).Port ) ); Clients = new List<TcpClient>(); messageHandler = new MessageHandler(); // Make the socket listener and thread Random randomPort = new Random(); listenerSocket = new TcpListener(IPAddress.Any, randomPort.Next(8900, 9000)); listenThread = new Thread(new ThreadStart(ListenForClients)); listenThread.Start(); sendServerPort(loadBalancerSocket, ((IPEndPoint)listenerSocket.LocalEndpoint).Port); Logger.ShowMessage("Listener initialized."); Logger.ShowMessage("Listening on: " + ((IPEndPoint)listenerSocket.LocalEndpoint).Address + ":" + ((IPEndPoint)listenerSocket.LocalEndpoint).Port); // Define the handlers. PacketManager.DefineOpcodeHandlers(); }