294 lines
7.8 KiB
C
294 lines
7.8 KiB
C
#include "central-manager.h"
|
|
|
|
/*
|
|
*
|
|
* @argv : {0:program name}
|
|
*
|
|
* @history
|
|
* [1] Lancement des THREADS d'écoute
|
|
* 1. On démarre le SERVEUR TCP d'écoute globale
|
|
* 2. On démarre le SERVEUR UDP d'écoute globale
|
|
* [2] On attends la fin de tous les THREADS
|
|
* [3] On ferme la SOCKET d'écoute globale
|
|
*
|
|
*/
|
|
int main(int argc, char* argv[]){
|
|
|
|
|
|
/* [1] Lancement des THREADS d'écoute
|
|
=========================================================*/
|
|
/* (1) Ecoute TCP */
|
|
pthread_create(&listenManagers[0], NULL, LISTEN_TCP, NULL);
|
|
if( DEBUGMOD&THR ) printf("LISTEN THREAD[TCP] démarré\n");
|
|
|
|
/* (2) Ecoute UDP */
|
|
pthread_create(&listenManagers[1], NULL, LISTEN_UDP, NULL);
|
|
if( DEBUGMOD&THR ) printf("LISTEN THREAD[UDP] démarré\n");
|
|
|
|
|
|
/* [2] On attends la fin de tous les THREADS
|
|
==========================================================*/
|
|
pthread_join(listenManagers[0], NULL);
|
|
pthread_join(listenManagers[1], NULL);
|
|
|
|
/* [3] On ferme la SOCKET d'écoute globale
|
|
==========================================================*/
|
|
printf("FERMETURE DE TOUTES LES CONNECTIONS!\n");
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Attente de connection TCP
|
|
*
|
|
* @history
|
|
* [0] Initialisation des variables
|
|
* [1] On démarre le SERVEUR TCP d'écoute globale
|
|
* [2] Attente d'une demande de connection TCP -> création d'un THREAD
|
|
* [3] On attends la fin de tous les THREADS
|
|
* [4] On ferme la SOCKET d'écoute TCP globale
|
|
*
|
|
*/
|
|
void* LISTEN_TCP(){
|
|
/* [0] Initialisation des variables
|
|
==========================================================*/
|
|
int CLIENT_SOCKET; // contiendra la socket TCP à envoyer sur un THREAD
|
|
struct sockaddr_in clientInfo; // contiendra les infos client
|
|
socklen_t len; // taille de la socket
|
|
int index, i; // compteurs
|
|
|
|
// retour de @DROP_TCP_SERVER
|
|
int LISTENSOCK; // contiendra la socket d'écoute TCP
|
|
|
|
|
|
/* [1] On démarre le SERVEUR TCP d'écoute globale
|
|
==========================================================*/
|
|
if( DROP_TCP_SERVER(TCP_PORT, &LISTENSOCK) < 0 ){
|
|
|
|
if( DEBUGMOD&SCK ) printf("\tErreur de mise en place de la socket d'écoute TCP\n");
|
|
|
|
// On ferme la SOCKET d'écoute globale
|
|
printf("\tFERMETURE DE L'ECOUTE TCP!\n");
|
|
close(LISTENSOCK);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
printf("\tTCP Listen Port: %d\n", TCP_PORT);
|
|
|
|
|
|
|
|
/* [2] Attente d'une demande de connection, pour création d'un THREAD
|
|
============================================================================*/
|
|
while( 1 ){
|
|
|
|
/* 1. On initialise les SOCKET en attendant la connexion et le rang du "manager" inactif */
|
|
CLIENT_SOCKET = -1;
|
|
index = -1;
|
|
|
|
/* 2. On attends une connection TCP */
|
|
CLIENT_SOCKET = accept(LISTENSOCK, (struct sockaddr*) &clientInfo, &len);
|
|
|
|
/* 3. Si erreur, on attend une nouvelle connection */
|
|
if( CLIENT_SOCKET < 0 ){
|
|
if( DEBUGMOD&SCK ) printf("\tErreur connection TCP\n");
|
|
break;
|
|
}
|
|
|
|
/* 4. On cherche un "manager" libre (inactif) */
|
|
for( i = 0 ; i < MAX_TCP_THR ; i++ )
|
|
if( activeTCPManagers[i] == 0 ){ index = i; break; }
|
|
|
|
// si on a trouvé un "manager" libre
|
|
if( index != -1 ){
|
|
|
|
/* 5. On lance un thread pour le traitement de ce client */
|
|
pthread_create(&TCPManagers[index], NULL, managePlane, (void*)(intptr_t) CLIENT_SOCKET);
|
|
|
|
if( DEBUGMOD&THR ) printf("\tTHREAD[TCP][%d] démarré\n", index);
|
|
|
|
/* 6. On signale que ce "manager" est maintenant actif */
|
|
activeTCPManagers[index] = 1;
|
|
|
|
}else
|
|
if( DEBUGMOD&THR ) printf("\tAucun thread TCP libre!\n");
|
|
|
|
}
|
|
|
|
|
|
/* [3] On attends la fin de tous les THREADS
|
|
==========================================================*/
|
|
for( i = 0 ; i < MAX_TCP_THR ; i++ )
|
|
pthread_join(TCPManagers[i], NULL);
|
|
|
|
/* [4] On ferme la SOCKET d'écoute globale
|
|
==========================================================*/
|
|
printf("FERMETURE DE L'ECOUTE TCP!\n");
|
|
close(LISTENSOCK);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Attente de connection UDP
|
|
*
|
|
* @history
|
|
* [0] Initialisation des variables
|
|
* [1] On démarre le SERVEUR UDP d'écoute globale
|
|
* [2] On attends un client
|
|
* [3] On gère la requête
|
|
* [4] On envoie la réponse
|
|
* [n] On ferme la SOCKET d'écoute UDP globale
|
|
*
|
|
*/
|
|
void* LISTEN_UDP(){
|
|
/* [0] Initialisation des variables
|
|
==========================================================*/
|
|
struct sockaddr_in clientInfo; // contiendra les infos client
|
|
char client_ip[20]; // IP du client
|
|
socklen_t len; // taille de la socket
|
|
int read; // compteurs
|
|
char request[MAX_BUF_LEN] = {0}; // buffer requête
|
|
// char response[MAX_BUF_LEN] = {0}; // buffer réponse
|
|
|
|
// retour de @DROP_UDP_SERVER
|
|
int SOCKET;
|
|
|
|
/* [1] On démarre le SERVEUR UDP d'écoute globale
|
|
==========================================================*/
|
|
if( DROP_UDP_SERVER(UDP_PORT, &SOCKET) < 0 ){
|
|
|
|
if( DEBUGMOD&SCK ) printf("\tErreur de mise en place de la socket UDP\n");
|
|
|
|
// On ferme la SOCKET d'écoute globale
|
|
printf("\tFERMETURE DE LA SOCKET UDP!\n");
|
|
close(SOCKET);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
printf("\tUDP Listen Port: %d\n", UDP_PORT);
|
|
|
|
|
|
|
|
/* [2] Attente de connection
|
|
============================================================================*/
|
|
while( 1 ){
|
|
|
|
/* 0. On vide les données */
|
|
bzero(request, MAX_BUF_LEN);
|
|
bzero(&clientInfo, sizeof(struct sockaddr_in));
|
|
|
|
/* 1. On attends une connection UDP */
|
|
read = recvfrom(SOCKET, request, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len);
|
|
|
|
/* 2. Si erreur reception */
|
|
if( read < 0 ){
|
|
if( DEBUGMOD&BUF ) printf("\t\t[UDP] READ = %d\n", read);
|
|
break;
|
|
}
|
|
|
|
/* 3. On récupère l'adresse IP du client */
|
|
inet_ntop(AF_INET, &(clientInfo.sin_addr), client_ip, 20);
|
|
|
|
if( DEBUGMOD&SCK ) printf("\t[UDP] %s connecté\n", client_ip);
|
|
|
|
|
|
/* 3. Gestion requête */
|
|
printf("\t\tRequest(%d bytes) : '%s'\n", read, request);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* [n] On ferme la SOCKET d'écoute globale
|
|
==========================================================*/
|
|
printf("\tFERMETURE DE LA SOCKET UDP!\n");
|
|
close(SOCKET);
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* Gestion d'une connexion PLANE
|
|
*
|
|
* @THREADABLE_SOCKET<void*> SOCKET de la connexion client
|
|
*
|
|
* @history
|
|
* [1] Initialisation des variables
|
|
* [2] Récupération de la requête
|
|
* [3] Traitement de la requête
|
|
* [4] Création de la réponse
|
|
* [5] Envoi de la réponse
|
|
* [6] On vide les buffers
|
|
* [7] Fermeture de la connection (SOCKET)
|
|
* [n] Arrêt du THREAD
|
|
* 1. On récupère le rang dans les "managers"
|
|
* 2. On met à jour "activeManagers"
|
|
* 3. On arrête le THREAD
|
|
*
|
|
*/
|
|
void* managePlane(void* THREADABLE_SOCKET){
|
|
|
|
/* [1] Initialisation des variables
|
|
=========================================================*/
|
|
int read; // compteur
|
|
int TCP_SOCKET = (intptr_t) THREADABLE_SOCKET; // Socket client
|
|
char request[MAX_BUF_LEN]; // Requête
|
|
// char response[MAX_BUF_LEN]; // Réponse
|
|
|
|
do{
|
|
|
|
/* [2] Récupération de la requête
|
|
=========================================================*/
|
|
/* 1. On lit sur la socket */
|
|
read = recv(TCP_SOCKET, request, MAX_BUF_LEN, 0);
|
|
|
|
/* 2. Si erreur reception */
|
|
if( read < 0 ){
|
|
if( DEBUGMOD&BUF ) printf("\t\t[TCP] READ = %d\n", read);
|
|
break;
|
|
}
|
|
|
|
/* 3. On désérialise la requête*/
|
|
|
|
|
|
printf("\t\tPLANE Request(%d bytes) : '%s'\n", read, request);
|
|
|
|
/* [3] Gestion de la requête
|
|
=========================================================*/
|
|
|
|
|
|
|
|
}while( 0 );
|
|
|
|
/* [n] Arrêt du THREAD
|
|
============================================================================*/
|
|
/* 1. On récupère le rang dans les "managers" */
|
|
int i, index = -1;
|
|
for( i = 0 ; i < MAX_TCP_THR ; i++ )
|
|
if( TCPManagers[i] == pthread_self() ){ index = i; break; }
|
|
|
|
/* 2. On met à jour "activeManagers" */
|
|
if( index != -1 )
|
|
activeTCPManagers[index] = 0;
|
|
|
|
/* 3. On arrête le THREAD */
|
|
if( DEBUGMOD&THR ) printf("\t\tTHREAD[TCP][%d] libéré\n", index);
|
|
pthread_exit(NULL);
|
|
}
|