/// <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);
}
