private void MonitorIncomingConnection() { listener.Start(); while (true) { try { if (Abort) { //Terminating Server and Monitoring Loop listener.Stop(); Trace.WriteLine(Name + ": TCP Server Stopped."); DisconnectAllClients(); return; } if (!listener.Pending()) { Thread.Sleep(10); } else { System.Net.Sockets.TcpClient client = listener.AcceptTcpClient(); Trace.WriteLine(Name + ": New Connection Detected..."); TcpServerConnectEventArgs eArgs = new TcpServerConnectEventArgs() { Client = client }; ClientConnecting?.Invoke(this, eArgs); if (eArgs.Accept) { //Connection Accepted TcpServerConnection newConnection = null; newConnection = new TcpServerConnection(this, client, Certificate); newConnection.MessageDelimiter = MessageDelimiter; Trace.WriteLine(Name + ": Connection Accepted: Client = " + newConnection.ClientIPAddress); newConnection.ClientDisconnected += OnClientDisconnected; lock (ActiveConnections) { ActiveConnections.Add(newConnection); } ClientConnected?.Invoke(this, new TcpServerEventArgs() { Client = newConnection }); } else { //Connection Refused Trace.WriteLine(Name + ": Connection Rejected."); client.Close(); } } } catch (Exception ex) { Trace.WriteLine("[WARNING] " + Name + ": Exception raised from Connection Monitoring Thread!\n" + ex.Message); continue; } } }
private void WriteExceptionErrorToClient(TcpServerConnection client, Exception ex) { string returnMsg = TcpAppCommandStatus.ERR + " " + ex.Message; TcpAppServerConnection appServerClient = AppClients.FirstOrDefault(x => x.Connection == client); string clientName = appServerClient == null?client.ClientIPAddress.ToString() : appServerClient.Name; Debug.WriteLine("AppServer[" + clientName + "]-Error: " + returnMsg); client.WriteLineToClient(returnMsg); }
private void WriteResultToClient(TcpServerConnection client, TcpAppInputCommand input) { string returnMsg = "#TCP# " + input.Command.Keyword + " " + input.Status.ToString(); if (!string.IsNullOrEmpty(input.OutputMessage)) { returnMsg += " " + input.OutputMessage; } client.WriteLineToClient(returnMsg); }
private void WriteResultToClient(TcpServerConnection client, TcpAppInputCommand input) { string returnMsg = input.Command.Keyword + " " + input.Status.ToString(); if (!string.IsNullOrEmpty(input.OutputMessage)) { returnMsg += " " + input.OutputMessage; } System.Diagnostics.Trace.WriteLine("Write To Client: " + returnMsg); client.WriteLineToClient(returnMsg); }
private TcpAppServerConnection AddClientToAppClientsList(TcpServerConnection client) { lock (AppClients) { TcpAppServerConnection result = new TcpAppServerConnection() { Connection = client, Name = "#" + client.ClientIPAddress.ToString() }; AppClients.Add(result); client.ProcessReceivedMessageCallback = Client_ProcessReceivedMessage; return(result); } }
private void OnClientDisconnected(object sender, EventArgs e) { Trace.WriteLine(Name + ": Client disconnected from server."); if (SuppressDisconnectEvent) { return; } TcpServerConnection client = sender as TcpServerConnection; ClientDisconnected?.Invoke(this, new TcpServerEventArgs() { Client = client }); client.Dispose(); ActiveConnections.Remove(client); }
internal TcpServerDataEventArgs(TcpServerConnection client, byte[] data, int length) { Client = client; Data = new byte[length]; Array.Copy(data, Data, length); }
private void MonitorIncomingConnection() { listener.Start(); while (true) { try { if (Abort) { //Terminating Server and Monitoring Loop listener.Stop(); Trace.WriteLine(Name + ": TCP Server Stopped."); DisconnectAllClients(); return; } if (!listener.Pending()) { Thread.Sleep(10); } else { System.Net.Sockets.TcpClient client = listener.AcceptTcpClient(); Trace.WriteLine(Name + ": New Connection Detected..."); if (MaxClients > 0) { //MAX Clients Restriction applied if (Clients.Count >= MaxClients) { //Number of connection exceeds, reject incoming connection. Trace.WriteLine(Name + ": Connection Rejected, exceed MAX allowed clients!"); byte[] msgBuffer = Encoding.ASCII.GetBytes("Connection Rejected, exceed MAX allowed clients!\r\n"); client.GetStream().Write(msgBuffer, 0, msgBuffer.Length); client.GetStream().Flush(); client.Close(); continue; } } TcpServerConnectEventArgs eArgs = new TcpServerConnectEventArgs() { Client = client }; ClientConnecting?.Invoke(this, eArgs); if (eArgs.Accept) { //Connection Accepted TcpServerConnection newConnection = new TcpServerConnection(this, client) { MessageDelimiter = MessageDelimiter }; Trace.WriteLine(Name + ": Connection Accepted: Client = " + newConnection.ClientIPAddress); newConnection.ClientDisconnected += OnClientDisconnected; lock (ActiveConnections) { ActiveConnections.Add(newConnection); } ClientConnected?.Invoke(this, new TcpServerEventArgs() { Client = newConnection }); } else { //Connection Refused Trace.WriteLine(Name + ": Connection Rejected."); client.Close(); } } } catch (Exception ex) { Trace.WriteLine("[WARNING] " + Name + ": Exception raised from Connection Monitoring Thread!\n" + ex.Message); continue; } } }
internal BytesReceivedEventArgs(TcpServerConnection client, byte[] data, int length) { Client = client; ReceivedBytes = new byte[length]; Array.Copy(data, ReceivedBytes, length); }
private void MonitorIncomingConnection() { listener.Start(); while (true) { try { if (Abort) { //Terminating Server and Monitoring Loop listener.Stop(); Trace.WriteLine(Name + ": TCP Server Stopped."); DisconnectAllClients(); return; } if (!listener.Pending()) { Thread.Sleep(10); } else { System.Net.Sockets.TcpClient client = listener.AcceptTcpClient(); var stream = client.GetStream(); byte[] wsData = null; Thread.Sleep(10); // 停10ms,否则获取握手时数据有可能取不到 if (stream.DataAvailable) { var buffer = new byte[client.ReceiveBufferSize]; var factLen = stream.Read(buffer, 0, buffer.Length); wsData = new byte[factLen]; Array.Copy(buffer, wsData, factLen); } Trace.WriteLine(Name + ": New Connection Detected..."); TcpServerConnectEventArgs eArgs = new TcpServerConnectEventArgs() { Client = client }; ClientConnecting?.Invoke(this, eArgs); if (eArgs.Accept) { //Connection Accepted TcpServerConnection newConnection = new TcpServerConnection(this, client) { MessageDelimiter = MessageDelimiter, WsData = wsData }; Trace.WriteLine(Name + ": Connection Accepted: Client = " + newConnection.ClientIPAddress); newConnection.ClientDisconnected += OnClientDisconnected; lock (ActiveConnections) { ActiveConnections.Add(newConnection); } ClientConnected?.Invoke(this, new TcpServerEventArgs() { Client = newConnection }); } else { //Connection Refused Trace.WriteLine(Name + ": Connection Rejected."); client.Close(); } } } catch (Exception ex) { Trace.WriteLine("[WARNING] " + Name + ": Exception raised from Connection Monitoring Thread!\n" + ex.Message); continue; } } }
private void Client_ProcessReceivedMessage(TcpServerConnection client, string message, byte[] messageBytes) { //Parse and Execute Commands string[] cmdArg = TcpAppCommon.ParseCommand(message.Trim()); //Process Command Keyword TcpAppCommand cmdHandler = GetCommand(cmdArg[0]); if (cmdHandler == null) { //Error - Unrecognized command. client.WriteLineToClient(string.Format("{0} {1} Invalid Command!", cmdArg[0], TcpAppCommandStatus.ERR.ToString())); return; } TcpAppInputCommand cmdInput = new TcpAppInputCommand() { Command = cmdHandler }; cmdInput.Arguments = cmdArg.Skip(1).ToArray(); //Move to TcpAppInputCommand //Process Parameters cmdHandler.ResetParametersValue(); int argID = 1; //First Parameter foreach (TcpAppParameter item in cmdHandler.Parameters) { if (argID >= cmdArg.Length) { //Argument with no input if (!item.IsOptional) { //Error - Missing required parameter cmdInput.OutputMessage = "Missing required parameter: " + item.Name + "!"; WriteResultToClient(client, cmdInput); return; } } else { item.Value = cmdArg[argID]; //Assign parameter value } argID++; } //Execute Commands try { cmdInput.Command.ExecuteCallback(cmdInput); } catch (Exception ex) { //Catch and report all execution error cmdInput.OutputMessage = "Exception Raised! " + ex.Message; cmdInput.Status = TcpAppCommandStatus.ERR; //Force status to error, make sure no surprise. } finally { WriteResultToClient(client, cmdInput); //Send result back to client. } }
private void Client_ProcessReceivedMessage(TcpServerConnection client, string message, byte[] messageBytes) { //Parse and Execute Commands string[] cmdArg = TcpAppCommon.ParseCommand(message.Trim()); try { //Register Client Connection TcpAppServerConnection ptrClient = AppClients.FirstOrDefault(x => x.Connection == client); if (ptrClient == null) { //Reconstruct device which had already signed out ptrClient = AddClientToAppClientsList(client); } Debug.WriteLine("AppServer[" + ptrClient.Name + "]-RX: " + message); TcpAppInputCommand inputCommand = TcpAppCommon.CreateInputCommand(Commands, cmdArg); if (inputCommand != null) { inputCommand.AppClient = ptrClient; } else//Command keyword not exist { //Check if command keyword is alias name ITcpAppServerPlugin plugin = _Plugins.FirstOrDefault(x => string.Compare(x.Alias, cmdArg[0], true) == 0); if (plugin != null) { //Execute plugin command inputCommand = plugin.GetPluginCommand(cmdArg.Skip(1).ToArray()); inputCommand.AppClient = ptrClient; BeforeExecutePluginCommand?.Invoke(this, new TcpAppServerExEventArgs(ptrClient) { Plugin = plugin }); } else { //Error - Unrecognized command. inputCommand = new TcpAppInputCommand() { Status = TcpAppCommandStatus.ERR, OutputMessage = "Invalid Command " + cmdArg[0] }; WriteResultToClient(ptrClient, inputCommand); return; } } //Verify Client had signed in. if (!inputCommand.AppClient.SignedIn && !inputCommand.Command.IsSystemCommand) { throw new Exception("Client not signed in! Execute SignIn first."); } if (inputCommand.Command.UseMessageQueue && !inputCommand.Command.IsSystemCommand) { //Single thread execution, post message to message queue. lock (CommandQueue) { inputCommand.ID = inputCommand.GetHashCode(); if (ptrClient.NextQueuedCommand == null) { ptrClient.NextQueuedCommand = inputCommand; //Set pointer to next queued command. } //Add Command to Queue CommandQueue.Add(inputCommand); CommandQueueWaitSignal?.Set(); inputCommand.OutputMessage = inputCommand.ID.ToString(); inputCommand.Status = TcpAppCommandStatus.QUEUED; } } else if (inputCommand.Command.IsSystemCommand) { inputCommand.ExecuteCallback(); } else { //Execute command, wait until return if (ExecutionTimeout == 0) { inputCommand.ExecuteCallback(); } //Execute command, terminate on timeout else { ptrClient.ExecuteCommandAsync(inputCommand, ExecutionTimeout); } } WriteResultToClient(ptrClient, inputCommand); //Send result back to client. } catch (Exception ex) { WriteExceptionErrorToClient(client, ex); } }