/// <summary> /// Connect the client to the EndPoint on SSL. /// </summary> /// <param name="endPoint">The remote end point</param> /// <param name="clientCertificatePath">The client certificate file</param> /// <param name="certificatePassword">The client certifciate password</param> public void Connect(IPEndPoint endPoint, string clientCertificatePath, string certificatePassword) { // Load the client certificte X509Certificate2 clientCertificate = new X509Certificate2(clientCertificatePath, certificatePassword); X509CertificateCollection clientCertificateList = new X509CertificateCollection(); clientCertificateList.Add(clientCertificate); // Connect the client to the remote end point TcpClient sslTcpClient = new TcpClient(); sslTcpClient.Connect(endPoint); sslTcpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, this.KeepAlive); // Open a ssl stream for the communication SslStream sslStream = new SslStream(sslTcpClient.GetStream(), false, new RemoteCertificateValidationCallback(this.OnVerifyCertificate)); sslStream.AuthenticateAsClient("NONE", clientCertificateList, SslProtocols.Ssl3, false); //TODO: params from config for mutual auth, protocol and revocation // Create the socket client handler, add the callback for the event and start to receiving Socket client = sslTcpClient.Client; client.Blocking = true; handler = GetHandler(client, sslStream); handler.ReceiveMessageEvent += new ReceiveMessageDelegate(handler_ReceiveMessageEvent); handler.CloseConnectionEvent += new SocketConnectionDelegate(handler_CloseConnectionEvent); handler.InReceivingEvent += new SocketConnectionDelegate(handler_InReceivingEvent); connected = true; this.OnConnection(handler); handler.StartReceive(); }
public virtual ClientInfo this[AbstractTcpSocketClientHandler abstractTcpSocketClientHandler] { get { return(this.clientList[abstractTcpSocketClientHandler]); } }
/// <summary> /// Raise an incoming message event. /// </summary> /// <param name="handler">The socket client handler of the close connection</param> void handler_InReceivingEvent(AbstractTcpSocketClientHandler handler) { if (inReceivingEvent != null) { inReceivingEvent(handler); } }
private void server_ConnectionEvent(AbstractTcpSocketClientHandler handler) { try { if (_server == null) { return; } ClientInfo[] clientList = _server.GetClientList(); if (clientList.Length != 0) { _count++; foreach (ClientInfo ci in clientList) { if (!_containerNames.ContainsKey(ci)) { _containerNames.Add(ci, "Unknown container " + _count); break; } } } DisplayContainerList(); RaiseNewTextEvent("Container connected to server."); } catch (Exception ex) { RaiseNewTextEvent("Exception in Server.ConnectionEvent: " + ex.Message + "."); } }
/// <summary> /// Accept callback method for not SSL connection /// </summary> /// <param name="ar">The socket server</param> private void AcceptCallback(IAsyncResult ar) { AbstractSocketServer server = (AbstractSocketServer)ar.AsyncState; try { // Get the socket that handles the client request. Socket handler = server.listener.EndAccept(ar); Trace.WriteLine("Start incoming connection ..."); handler.Blocking = true; AbstractTcpSocketClientHandler clientHandler = this.GetHandler(handler, null); clientHandler.KeepAlive = this.KeepAlive; clientHandler.ReceiveMessageEvent += new ReceiveMessageDelegate(server.OnReceiveMessage); clientHandler.CloseConnectionEvent += new SocketConnectionDelegate(server.clientHandler_CloseConnectionEvent); // Add the clilent to the client list server.clientList.AddClient(this.GetClientInfo(clientHandler)); // Notify the connection event server.OnConnection(clientHandler); // Start to receive data from this client clientHandler.StartReceive(); Trace.WriteLine("New connection completed"); } catch (Exception ex) { Trace.WriteLine(string.Format("Failed to accept incoming connection. Exception", ex)); } finally { // Signal the main thread to continue. server.listenerCompleteConnectionEvent.Set(); } }
void worker_DoWork(object sender, DoWorkEventArgs e) { while (true) { if (_Server == null) { continue; } if (isServerStarted == false) { continue; } ClientInfo[] clientList = _Server.GetClientList(); foreach (ClientInfo client in clientList) { AbstractTcpSocketClientHandler clientHandler = client.TcpSocketClientHandler; if (clientHandler.Connected == false) { Trace.WriteLine(String.Format("Disconnected: {0}", clientHandler.GetHashCode().ToString())); clientHandler.Close(); } } Thread.Sleep(5000); } }
/// <summary> /// Raise the receive message event. /// </summary> /// <param name="handler">The socket client handler for the received message</param> /// <param name="abstractMessage">The message received</param> protected virtual void OnReceiveMessage(AbstractTcpSocketClientHandler handler, AbstractMessage abstractMessage) { if (receiveMessageEvent != null) { receiveMessageEvent(handler, abstractMessage); } }
/// <summary> /// Raise the new conection event. /// </summary> /// <param name="handler">The socket client handler connected</param> protected virtual void OnConnection(AbstractTcpSocketClientHandler handler) { if (connectionEvent != null) { connectionEvent(handler); } }
void Server_lostConnection(AbstractTcpSocketClientHandler handler) { if (LostConnection != null) { LostConnection(handler.GetHashCode().ToString()); } }
/// <summary> /// Raise a close connection event. /// </summary> /// <param name="handler">The socket client handler of the close connection</param> void handler_CloseConnectionEvent(AbstractTcpSocketClientHandler handler) { connected = false; if (closeConnectionEvent != null) { closeConnectionEvent(handler); } }
/// <summary> /// Raise the close connection event. /// </summary> /// <param name="handler">The socket client handler disconnected</param> protected virtual void clientHandler_CloseConnectionEvent(AbstractTcpSocketClientHandler handler) { clientList.RemoveClient(clientList[handler]); if (closeConnectionEvent != null) { closeConnectionEvent(handler); } }
void Server_onConnection(AbstractTcpSocketClientHandler handler) { handler.KeepAlive = true; if (OnClientConnection != null) { OnClientConnection(handler.GetHashCode().ToString()); } }
/// <summary> /// Close and dispose the client. /// </summary> public void Dispose() { if (handler != null) { handler.Close(); handler.Dispose(); handler = null; } }
/// <summary> /// Dispose the client. /// </summary> public void Dispose() { if (this.abstractTcpSocketClientHandler == null) { return; } this.abstractTcpSocketClientHandler.Dispose(); this.abstractTcpSocketClientHandler = null; }
private void client_CloseConnectionEvent(AbstractTcpSocketClientHandler handler) { try { RaiseNewTextEvent("Container disconnected from server."); } catch (Exception ex) { RaiseNewTextEvent(ex.Message); } }
private void client_ConnectionEvent(AbstractTcpSocketClientHandler handler) { try { RaiseNewTextEvent("Container connected to server."); Register(); RaiseNewTextEvent($"{_name} registered."); } catch (Exception ex) { RaiseNewTextEvent(ex.Message); } }
/// <summary> /// Get from the client list the Client Info connected to the specific socket client handler. /// </summary> /// <param name="abstractTcpSocketClientHandler">The socket client handler to find</param> /// <returns>The client info of the socket client handler</returns> public virtual ClientInfo this[AbstractTcpSocketClientHandler abstractTcpSocketClientHandler] { get { lock (this) { if (!this.clientList.ContainsKey(abstractTcpSocketClientHandler)) { return(null); } return((ClientInfo)this.clientList[abstractTcpSocketClientHandler]); } } }
private void buttonSend_Click(object sender, EventArgs e) { ClientInfo[] clientList = this.server.GetClientList(); if (clientList.Length == 0) { MessageBox.Show("The client is not connected", "Socket Server", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } AbstractTcpSocketClientHandler clientHandler = clientList[0].TcpSocketClientHandler; string s = this.textBoxSend.Text; byte[] buffer = System.Text.ASCIIEncoding.Unicode.GetBytes(s); BasicMessage message = new BasicMessage(this.serverGuid, buffer); clientHandler.SendAsync(message); }
/// <summary> /// Connect the client to the EndPoint. /// </summary> /// <param name="endPoint">The remote end point</param> public void Connect(IPEndPoint endPoint) { // Connect the client to the remote end point Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.KeepAlive, this.KeepAlive); client.Connect(endPoint); client.Blocking = true; // Create the socket client handler, add the callback for the event and start to receiving handler = GetHandler(client, null); handler.ReceiveMessageEvent += new ReceiveMessageDelegate(handler_ReceiveMessageEvent); handler.CloseConnectionEvent += new SocketConnectionDelegate(handler_CloseConnectionEvent); handler.InReceivingEvent += new SocketConnectionDelegate(handler_InReceivingEvent); connected = true; this.OnConnection(handler); handler.StartReceive(); }
public override void broadcastMessage(byte[] data) { ClientInfo[] clientList = _Server.GetClientList(); foreach (ClientInfo client in clientList) { AbstractTcpSocketClientHandler clientHandler = client.TcpSocketClientHandler; BasicMessage message = new BasicMessage(_ServerGuid, data); try { clientHandler.SendAsync(message); } catch (Exception) { Trace.WriteLine(String.Format("failed to send data :{0}", clientHandler.GetHashCode().ToString())); } } }
/// <summary> /// Accept callback method for SSL connection. /// </summary> /// <param name="ar">The socket server</param> private void AcceptSSLCallback(IAsyncResult ar) { AbstractSocketServer server = (AbstractSocketServer)ar.AsyncState; SslStream sslStream = null; try { // Get the socket that handles the client request. TcpClient sslTcpClient = server.sslListener.EndAcceptTcpClient(ar); Trace.WriteLine("Start incoming ssl connection ..."); sslStream = new SslStream(sslTcpClient.GetStream(), false, new RemoteCertificateValidationCallback(server.OnVerifyClientCertificate)); sslStream.AuthenticateAsServer(server.serverCertificate, true, SslProtocols.Ssl3, false); Socket handler = sslTcpClient.Client; handler.Blocking = true; AbstractTcpSocketClientHandler clientHandler = this.GetHandler(handler, sslStream); clientHandler.KeepAlive = this.KeepAlive; clientHandler.ReceiveMessageEvent += new ReceiveMessageDelegate(server.OnReceiveMessage); clientHandler.CloseConnectionEvent += new SocketConnectionDelegate(server.clientHandler_CloseConnectionEvent); server.OnConnection(clientHandler); server.clientList.AddClient(this.GetClientInfo(clientHandler)); clientHandler.StartReceive(); Trace.WriteLine("New connection completed"); } catch (Exception ex) { Trace.WriteLine(string.Format("Failed to accept incoming connection. Exception", ex)); try { if (sslStream != null) { sslStream.Close(); sslStream.Dispose(); } } catch (Exception ex2) { Trace.WriteLine(ex2); } } finally { // Signal the main thread to continue. server.listenerCompleteConnectionEvent.Set(); } }
private void client_ReceiveMessageEvent(AbstractTcpSocketClientHandler handler, AbstractMessage message) { try { var receivedMessage = (BasicMessage)message; byte[] buffer = receivedMessage.GetBuffer(); string s = ASCIIEncoding.Unicode.GetString(buffer); if (ContainerMessage.Deserialize(s) is ContainerMessage deserializedMessage) { ProcessMessage(deserializedMessage); } } catch (Exception ex) { RaiseNewTextEvent(ex.Message); } }
private void server_CloseConnectionEvent(AbstractTcpSocketClientHandler handler) { try { foreach (ClientInfo ci in _containerNames.Keys) { if (ci.TcpSocketClientHandler == handler) { _containerNames.Remove(ci); DisplayContainerList(); RaiseNewTextEvent("Container disconnected from server."); break; } } } catch (Exception ex) { RaiseNewTextEvent("Exception in Server.CloseConnectionEvent: " + ex.Message + "."); } }
public override void sendMessage(byte[] data, List <string> desireReceiver) { ClientInfo[] clientList = _Server.GetClientList(); foreach (ClientInfo client in clientList) { AbstractTcpSocketClientHandler clientHandler = client.TcpSocketClientHandler; foreach (string receiver in desireReceiver) { if (clientHandler.GetHashCode().ToString().CompareTo(receiver) == 0) { BasicMessage message = new BasicMessage(_ServerGuid, data); try { clientHandler.SendAsync(message); } catch (Exception) { Trace.WriteLine(String.Format("failed to send data :{0}", receiver)); } } } } }
private void server_ReceiveMessageEvent(AbstractTcpSocketClientHandler handler, AbstractMessage message) { try { BasicMessage receivedMessage = (BasicMessage)message; byte[] buffer = receivedMessage.GetBuffer(); string s = System.Text.ASCIIEncoding.Unicode.GetString(buffer); ClientInfo[] clientList = _server.GetClientList(); if (clientList.Length == 0) { return; } ClientInfo sender = null; foreach (ClientInfo ci in clientList) { if (ci.TcpSocketClientHandler == handler) { sender = ci; break; } } var deserializedMessage = ContainerMessage.Deserialize(s) as ContainerMessage; if (deserializedMessage != null) { ProcessMessage(deserializedMessage, sender); } } catch (Exception ex) { RaiseNewTextEvent("Exception in Server.ReceiveMessageEvent: " + ex.Message + "."); } }
/// <summary> /// Override this method to change the instace used for the Client Info /// </summary> /// <param name="abstractTcpSocketClientHandler">The socket client handler for the cient info</param> /// <returns>The client info contains the socket clilent handler</returns> protected virtual ClientInfo GetClientInfo(AbstractTcpSocketClientHandler abstractTcpSocketClientHandler) { return(new ClientInfo(abstractTcpSocketClientHandler)); }
void server_ConnectionEvent(AbstractTcpSocketClientHandler handler) { MessageBox.Show(string.Format("A client is connected to the server"), "Socket Server", MessageBoxButtons.OK, MessageBoxIcon.Information); }
/// <summary> /// Constructor. /// </summary> /// <param name="abstractTcpSocketClientHandler">The socket client handler</param> public ClientInfo(AbstractTcpSocketClientHandler abstractTcpSocketClientHandler) { this.abstractTcpSocketClientHandler = abstractTcpSocketClientHandler; this.clientUID = this.abstractTcpSocketClientHandler.ToString(); }
/// <summary> /// Raise a received message event. /// </summary> /// <param name="handler">The socket client handler of the close connection</param> /// <param name="message">The message received</param> void handler_ReceiveMessageEvent(AbstractTcpSocketClientHandler handler, AbstractMessage message) { OnReceiveMessage(handler, message); }