/// <summary> /// Send data. /// </summary> /// <param name="pConnectioHandle">Network connection to use</param> /// <param name="pMsg">Data to send</param> /// <returns>Send status</returns> public bool Send(TcpConnectionHandle pConnectioHandle, byte[] pMsg) { try { if (pConnectioHandle != null) { TcpClient tcpClient = pConnectioHandle.ConnectionClient; if (tcpClient != null & tcpClient.Connected) { NetworkStream clientStream = tcpClient.GetStream(); if (clientStream != null) { clientStream.Write(pMsg, 0, pMsg.Length); clientStream.Flush(); return(true); } return(false); } return(false); } return(false); } catch (Exception ex) { Logger.Error("Exception raised sending message.", ex); return(false); } }
/// <summary> /// Create a new MessageData object. /// </summary> /// <param name="pMsg">Message content</param> /// <param name="pMsgLength">Message length</param> /// <param name="pRemoteEndPoint">Remote endpoint</param> /// <param name="pCnxHandle">Handle of the TCP connection</param> public MessageData(byte[] pMsg, int pMsgLength, EndPoint pRemoteEndPoint, TcpConnectionHandle pCnxHandle) { Message = pMsg; MessageLength = pMsgLength; RemoteEndPoint = pRemoteEndPoint; _connectionHandle = pCnxHandle; }
/// <summary> /// Close a connection. /// </summary> /// <param name="cnxHandle">Connection to close</param> public void KillClient(TcpConnectionHandle cnxHandle) { try { if (cnxHandle != null) { OnCloseMessageReceived(new MessageData(null, 0, cnxHandle.ConnectionClient.Client.RemoteEndPoint, cnxHandle)); // Stop tcpclient. cnxHandle.ConnectionClient.Client.Shutdown(SocketShutdown.Both); cnxHandle.ConnectionClient.Client.Close(); cnxHandle.ConnectionClient.Close(); // Kill the thread. cnxHandle.ConnectionThread.Join(50); lock (TcpConnectionHandler) { TcpConnectionHandler.Remove(cnxHandle); } cnxHandle = null; } } catch (Exception ex) { Logger.Error("Exception raised killing tcpconnectionhandle.", ex); } }
/// <summary> /// Send data. /// </summary> /// <param name="pConnectioHandle">Network connection to use</param> /// <param name="pMsg">Data to send</param> /// <returns>Send status</returns> public bool Send(TcpConnectionHandle pConnectioHandle, string pMsg) { UTF8Encoding encoder = new UTF8Encoding(); byte[] buffer = encoder.GetBytes(pMsg); return(this.Send(pConnectioHandle, buffer)); }
/// <summary> /// Handle communication with remote client. /// Called by ClientsListener thread. /// </summary> /// <param name="handle">TcpClient Object</param> protected virtual void ReceiveDataFromClient(object handle) { byte[] buffer = new byte[Buffer_size]; byte[] message; int bytesRead; MessageData msgData; TcpConnectionHandle connectionHandle = (TcpConnectionHandle)handle; // Create the tcpClient object to handle communication with the remote client. TcpClient tcpClient = connectionHandle.ConnectionClient; NetworkStream clientStream = tcpClient.GetStream(); //NetworkStream stream = client.GetStream(); //Int32 i; //Byte[] buffer; //String result = string.Empty; //do { // buffer = new Byte[128]; // i = stream.Read(buffer, 0, buffer.Length); // result += ASCIIEncoding.ASCII.GetString(buffer); //} while(stream.DataAvailable); while (true) { bytesRead = 0; try { // Blocks until a client sends a message. bytesRead = clientStream.Read(buffer, 0, Buffer_size); } catch { // A socket error has occurred. this.KillClient(tcpClient); break; } if (bytesRead == 0) { // The client has disconnected from the server. this.KillClient(tcpClient); break; } // NOTE : Single data buffer is supported here, better work with a second buffer (stringbuilder ?) // to handle data longuest than 4Kb... // Copy message data to correctly sized array. message = new byte[bytesRead]; Array.Copy(buffer, message, bytesRead); msgData = new MessageData(message, bytesRead, tcpClient.Client.RemoteEndPoint, connectionHandle); // Send event to dispatch the new message. this.OnMessageReceived(msgData); msgData = null; } if (!_usePermanentConnection) { // Close the connection, exit the thread. this.KillClient(tcpClient); } }
/// <summary> /// Thread that wait for a connection. /// </summary> protected void ClientsListener() { try { TcpConnectionHandle connectionHandle = null; try { _tcpListener.Start(); } catch (Exception ex) { _LastException = ex; _isRunning = false; return; } _isRunning = true; while (true) { TcpClient client; try { // Blocks until a client has connected to the server. client = _tcpListener.AcceptTcpClient(); } catch (Exception ex) { Logger.Error("Exception raised accepting tcp client connection.", ex); break; } // If the whitelist is used only whitelisted IP address is allowed. if (_useWhitelist && !this.IsWhitelisted(((IPEndPoint)client.Client.RemoteEndPoint).Address)) { this.KillClient(client); continue; } // If the blacklist is used blacklisted IP address is rejected. if (_useBlacklist && this.IsBlacklisted(((IPEndPoint)client.Client.RemoteEndPoint).Address)) { this.KillClient(client); continue; } // Create a thread to handle communication with connected client. Thread clientThread = new Thread(new ParameterizedThreadStart(ReceiveDataFromClient)); clientThread.Name = "TcpReceiver"; connectionHandle = new TcpConnectionHandle(clientThread, client); //if (_usePermanentConnection) //{ // // Keep a track of active thread. // _connectionList.Add(connectionHandle); //} byte[] tmp = BitConverter.GetBytes(clientThread.ManagedThreadId); OnNewConnection(new MessageData(tmp, tmp.Length, client.Client.RemoteEndPoint, connectionHandle)); clientThread.Start(connectionHandle); client = null; tmp = null; } } catch (Exception ex) { Logger.Error("Exception raised in client listener.", ex); } }
/// <summary> /// Send data. /// </summary> /// <param name="pConnectioHandle">Network connection to use</param> /// <param name="pMsg">Single byte to send</param> /// <returns>Send Status</returns> public bool Send(TcpConnectionHandle pConnectioHandle, byte pMsg) { return(this.Send(pConnectioHandle, new byte[] { pMsg })); }