/// <summary>
/// Méthode du processus léger écoutant les connexions des clients. A chaque nouveau client est associé un processus léger ainsi qu'une socket.
/// </summary>
private void listenConnect()
{
Socket clientSocket = null;
MySocket clientMySocket = null;
while (true)
{
try {
clientSocket = listener.AcceptSocket();
clientMySocket = new MySocket(clientSocket);
//Un client se connecte, démarrage un processus léger:
Thread clientThread = new Thread(receiveClientMsg);
clientThread.Start(clientMySocket);
//Ajout du client dans la table de hachage:
clients.Add(clientMySocket, clientThread);
//Création et levée de l'évènement:
ServerEventArgs e = new ServerEventArgs(clientMySocket.Id, ServerEventArgs.typeEvent.CONNEXION, null);
serverSocketReceiveEvent(this, e);
}
catch {
break;
}
}
}
public void serverEventFunc(object sender, SocketLibrary.ServerEventArgs e)
{
switch (e.Type)
{
case ServerEventArgs.typeEvent.MESSAGE: //dans cet exemple on fait un écho dès la réception du message
byte[] count = new byte[4];
count = BitConverter.GetBytes(e.Msg.Length);
byte[] msgecho = new byte[4 + e.Msg.Length];
count.CopyTo(msgecho, 0);
e.Msg.CopyTo(msgecho, 4);
//test the msg at server
string ss = Encoding.Default.GetString(e.Msg);
setMsgecho(ss);
if (!myServer.send(e.Id, msgecho))
{
Console.WriteLine("client déconnecté");
}
//client déconnecté
break;
case ServerEventArgs.typeEvent.CONNEXION:
//Un client s'est connecté. (e.Msg = null)
MessageBox.Show("Connexion du client " + e.Id, "co", MessageBoxButtons.OK);
break;
case ServerEventArgs.typeEvent.DECONNEXION:
//Un client s'est déconnecté. (e.Msg = null)
MessageBox.Show("Déconnexion du client " + e.Id, "déco", MessageBoxButtons.OK);
break;
}
}
public bool Send(int id, byte[] msg)
{
try {
foreach (MySocket ms in clients.Keys)
{
if (ms.Id == id)
{
ms.Socket.Send(msg, SocketFlags.None);
return(true);
}
}
return(false);
}
catch {
ServerEventArgs e = new ServerEventArgs(id, ServerEventArgs.typeEvent.DECONNEXION, null);
serverSocketReceiveEvent(this, e);
MySocket.addFreeId(id, getBiggestId());
return(false);
}
}
/// <summary>
/// Méthode du processus léger écoutant les messages des clients. Le processus léger est bloquant sur le receive, et implique que la taille du message soit contenue dans les quatre premiers octets de celui-ci.
/// Un event est levé à chaque réception de message.
/// </summary>
private void receiveClientMsg(Object o)
{
MySocket cs = (MySocket)o;
while (true)
{
try {
//Les quatre premiers octets contiennent la taille du message:
byte[] count = new byte[4];
cs.Socket.Receive(count, SocketFlags.None);
//La taille du message est maintenant connue:
byte[] msg = new byte[BitConverter.ToInt32(count, 0)];
cs.Socket.Receive(msg, msg.Length, SocketFlags.None);
//Création et levée de l'évènement:
ServerEventArgs e = new ServerEventArgs(cs.Id, ServerEventArgs.typeEvent.MESSAGE, msg);
serverSocketReceiveEvent(this, e);
}
catch {
if (cs.Socket != null)
{
//Erreur durant la réception du message, le client est déconnecté:
cs.Socket.Close();
}
if (serverSocketReceiveEvent != null)
{
ServerEventArgs e = new ServerEventArgs(cs.Id, ServerEventArgs.typeEvent.DECONNEXION, null);
serverSocketReceiveEvent(this, e);
MySocket.addFreeId(cs.Id, getBiggestId());
Thread thisThread = clients[cs];
clients.Remove(cs);
thisThread.Abort();
}
break;
}
}
}
/// <summary>
/// Intercepter un évenement, puis créer un ServerToolsEvent correspondant à son type.
/// </summary>
private void HandleServerEvent(object sender, ServerEventArgs e)
{
ServerToolsEvent sta = null;
switch (e.Type) {
case ServerEventArgs.typeEvent.CONNEXION:
sta = new ServerToolsEvent(e.Id, ServerToolsEvent.typeEvent.CONNEXION, null, null, null, -1);
break;
case ServerEventArgs.typeEvent.DECONNEXION:
sta = new ServerToolsEvent(e.Id, ServerToolsEvent.typeEvent.DECONNEXION, null, null, null, -1);
break;
case ServerEventArgs.typeEvent.MESSAGE:
Message msg = MessageUtil.decoder(e.Msg);
sta = new ServerToolsEvent(e.Id, ServerToolsEvent.typeEvent.MESSAGE, msg.Operation, msg.ListParams, msg.Source, int.Parse(msg.Stamp));
break;
}
serverToolsReceiveEvent(this, sta);
}
/// <summary>
/// Méthode du processus léger écoutant les messages des clients. Le processus léger est bloquant sur le receive, et implique que la taille du message soit contenue dans les quatre premiers octets de celui-ci.
/// Un event est levé à chaque réception de message.
/// </summary>
private void receiveClientMsg(Object o)
{
MySocket cs = (MySocket)o;
while (true) {
try {
//Les quatre premiers octets contiennent la taille du message:
byte[] count = new byte[4];
cs.Socket.Receive(count, SocketFlags.None);
//La taille du message est maintenant connue:
byte[] msg = new byte[BitConverter.ToInt32(count, 0)];
cs.Socket.Receive(msg, msg.Length, SocketFlags.None);
//Création et levée de l'évènement:
ServerEventArgs e = new ServerEventArgs(cs.Id, ServerEventArgs.typeEvent.MESSAGE, msg);
serverSocketReceiveEvent(this, e);
}
catch {
if (cs.Socket != null) {
//Erreur durant la réception du message, le client est déconnecté:
cs.Socket.Close();
}
if (serverSocketReceiveEvent != null) {
ServerEventArgs e = new ServerEventArgs(cs.Id, ServerEventArgs.typeEvent.DECONNEXION, null);
serverSocketReceiveEvent(this, e);
MySocket.addFreeId(cs.Id, getBiggestId());
Thread thisThread = clients[cs];
clients.Remove(cs);
thisThread.Abort();
}
break;
}
}
}
/// <summary>
/// Méthode du processus léger écoutant les connexions des clients. A chaque nouveau client est associé un processus léger ainsi qu'une socket.
/// </summary>
private void listenConnect()
{
Socket clientSocket = null;
MySocket clientMySocket = null;
while (true) {
try {
clientSocket = listener.AcceptSocket();
clientMySocket = new MySocket(clientSocket);
//Un client se connecte, démarrage un processus léger:
Thread clientThread = new Thread(receiveClientMsg);
clientThread.Start(clientMySocket);
//Ajout du client dans la table de hachage:
clients.Add(clientMySocket, clientThread);
//Création et levée de l'évènement:
ServerEventArgs e = new ServerEventArgs(clientMySocket.Id, ServerEventArgs.typeEvent.CONNEXION, null);
serverSocketReceiveEvent(this, e);
}
catch {
break;
}
}
}
public bool Send(int id, byte[] msg)
{
try {
foreach (MySocket ms in clients.Keys) {
if (ms.Id == id) {
ms.Socket.Send(msg, SocketFlags.None);
return true;
}
}
return false;
}
catch {
ServerEventArgs e = new ServerEventArgs(id, ServerEventArgs.typeEvent.DECONNEXION, null);
serverSocketReceiveEvent(this, e);
MySocket.addFreeId(id, getBiggestId());
return false;
}
}
private void HandleServerEvent(object sender, ServerEventArgs e)
{
ServerToolsEvent sta = null;
switch (e.Type) {
case ServerEventArgs.typeEvent.CONNEXION:
sta = new ServerToolsEvent(e.Id, ServerToolsEvent.typeEvent.CONNEXION, null, null);
break;
case ServerEventArgs.typeEvent.DECONNEXION:
sta = new ServerToolsEvent(e.Id, ServerToolsEvent.typeEvent.DECONNEXION, null, null);
break;
case ServerEventArgs.typeEvent.MESSAGE:
//Décoder opération demandée
sta = new ServerToolsEvent(e.Id, ServerToolsEvent.typeEvent.MESSAGE, "operation", new List<byte[]>() { new byte[] { } });
break;
}
serverToolsReceiveEvent(this, sta);
}
