#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[]){ printf("Execution tree structure\n"); printf("[procedureName]\n"); printf("{threadName}\n"); printf("[parent]{child}[subchild] Description\n\n\n"); /* [1] Lancement des THREADS d'écoute =========================================================*/ /* (1) Ecoute TCP */ pthread_create(&listenManagers[0], NULL, LISTEN_TCP, (void*)(intptr_t) TCP_LIST); if( DEBUGMOD&THR ) printf("{tcp_listen} démarré\n"); /* (2) Ecoute UDP multicast */ // pthread_create(&listenManagers[1], NULL, LISTEN_UDP, (void*)(intptr_t) TCP_); // if( DEBUGMOD&THR ) printf("{udp_mcas émarré\n\n"); /* (3) Ecoute UDP viewTerm */ pthread_create(&listenManagers[2], NULL, LISTEN_UDP, (void*)(intptr_t) UDP_VTER); if( DEBUGMOD&THR ) printf("{udp_vterm} démarré\n"); /* (4) Ecoute UDP ctrlTerm */ pthread_create(&listenManagers[3], NULL, LISTEN_UDP, (void*)(intptr_t) UDP_CTER); if( DEBUGMOD&THR ) printf("{udp_cterm} démarré\n"); /* [2] On attends la fin de tous les THREADS ==========================================================*/ for( char i = 0 ; i < 4 ; i++ ) pthread_join(listenManagers[(int)i], 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_LIST, &LISTENSOCK) < 0 ){ if( DEBUGMOD&SCK ) printf("{tcp_listen} Erreur création socket d'écoute\n"); // On ferme la SOCKET d'écoute globale printf("{tcp_listen} FERMETURE SOCKET D'ECOUTE TCP!\n"); close(LISTENSOCK); return NULL; } printf("{tcp_listen} Port écoute: %d\n", TCP_LIST); /* [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("{tcp_listen} accept: Erreur connection\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("{tcp_listen}{com}(%d) démarré\n", index); /* 6. On signale que ce "manager" est maintenant actif */ activeTCPManagers[index] = 1; }else if( DEBUGMOD&THR ) printf("{tcp_listen} Aucun thread 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("{tcp_listen} FERMETURE SOCKET D'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 ouvre une socket client sur un nouveau port (si ok) * [5] On envoie la réponse * [6] On démarre un thread de gestion avec timeout (en attente du client redirigé) * */ void* LISTEN_UDP(void* THREADABLE_PORT){ /* [0] Initialisation des variables ==========================================================*/ int CLIENT_SOCKET; // contiendra la socket UDP à envoyer sur un THREAD struct sockaddr_in listenInfo; // contiendra les infos de la socket LISTEN struct sockaddr_in comInfo; // contiendra les infos de la socket COM struct sockaddr_in clientInfo; // contiendra les infos client char client_ip[INET_ADDRSTRLEN]; // IP (string) du client socklen_t len; // taille de la socket int read; // compteurs char buffer[MAX_BUF_LEN]; // buffer requête struct bind_header request; // requête parsée int i, index; // compteurs int UDP_PORT = (intptr_t) THREADABLE_PORT; // Port serveur char xterm = (UDP_PORT==UDP_VTER) ? 'v' : 'c'; // terminal type identifier // retour de @DROP_UDP_SERVER int SOCKET; /* [1] On démarre le SERVEUR UDP d'écoute globale ==========================================================*/ if( DROP_UDP_SERVER(UDP_PORT, &SOCKET, &listenInfo) < 0 ){ if( DEBUGMOD&SCK ) printf("{udp_%cterm} Erreur de création socket d'écoute\n", xterm); // On ferme la SOCKET d'écoute globale printf("{udp_%cterm} FERMETURE SOCKET D'ECOUTE UDP!\n", xterm); close(SOCKET); return NULL; } printf("{udp_%cterm} Listen Port: %d\n", xterm, UDP_PORT); /* [2] Attente de connection ============================================================================*/ while( 1 ){ /* 0. On initialise les SOCKET en attendant la connexion d'un client */ CLIENT_SOCKET = -1; index = -1; /* 1. On attends une connection UDP */ len = sizeof(struct sockaddr_in); read = recvfrom(SOCKET, buffer, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len); /* 2. Si erreur reception ou taille incorrecte -> retour à l'écoute */ if( read < BINDHDR_LEN ){ if( DEBUGMOD&BUF ) printf("{udp_%cterm} read('%s') = %d bytes (expected: %d)\n", xterm, buffer, read, (int) (BINDHDR_LEN) ); continue; } /* 3. On récupère l'adresse IP du client */ inet_ntop(AF_INET, &(clientInfo.sin_addr), client_ip, INET_ADDRSTRLEN); if( DEBUGMOD&SCK ) printf("{udp_%cterm} '%s' connecté\n", xterm, client_ip); /* 4. On parse la requête */ memcpy(&request.flags, buffer, sizeof(char)); memcpy(&request.port, buffer+sizeof(char), sizeof(unsigned short)); printf("{udp_%cterm} received: bind_header{flag = %d; port = %d}\n", xterm, (int) request.flags, request.port); /* 5 Si on veut un port de communicatin */ if( request.flags&BINDHEAD_PRT ){ /* 5.1 On bind une socket sur un port random */ if( DROP_UDP_SERVER(0, &CLIENT_SOCKET, &comInfo) < 0 ){ if( DEBUGMOD&SCK ) printf("{udp_%cterm} Erreur de création de la socket COM\n", xterm); // On ferme la SOCKET CLIENT close(CLIENT_SOCKET); // On retire le flags PORT pour dire qu'on a pas pu ouvrir une socket de comm. request.flags -= BINDHEAD_PRT; } } /* 5.2 Si on veut on port de communication */ if( request.flags&BINDHEAD_PRT ){ /* On récupère le port de la socket de communication */ len = sizeof(struct sockaddr_in); if( getsockname(CLIENT_SOCKET, (struct sockaddr*) &comInfo, &len) < 0 ){ if( DEBUGMOD&SCK ) printf("{udp_%cterm} Erreur de recherche du port COM ouvert\n", xterm); close(CLIENT_SOCKET); // On retire le flags PORT pour dire qu'on a pas pu ouvrir une socket de comm. request.flags -= BINDHEAD_PRT; // Si on a le port -> on le met dans la reponse }else{ request.port = htons(comInfo.sin_port); if( DEBUGMOD&SCK ) printf("{udp_%cterm}{udp_com} Comm. socket is on port %d\n", xterm, request.port); } } /* 8. On envoie la réponse */ bzero(buffer, MAX_BUF_LEN); memcpy(buffer, &request.flags, sizeof(char)); memcpy(buffer+sizeof(char), &request.port, sizeof(unsigned short)); len = sizeof(struct sockaddr_in); if( sendto(SOCKET, buffer, BINDHDR_LEN/sizeof(char) + 1, 0, (struct sockaddr*) &clientInfo, len) < 0 ){ printf("{udp_%cterm} Impossible de répondre au client!\n", xterm); continue; } printf("{udp_%cterm} sent: bind_header{flag = %d; port = %d}\n", xterm, (int) request.flags, request.port); /* 9. On cherche un "manager" libre (inactif) */ for( i = 0 ; i < MAX_UDP_THR ; i++ ) if( activeUDPManagers[i] == 0 ){ index = i; break; } // si on a trouvé un "manager" libre if( index != -1 ){ /* 9.1. On lance un thread pour le traitement de ce client */ pthread_create(&UDPManagers[index], NULL, manageTerminal, (void*)(intptr_t) CLIENT_SOCKET); if( DEBUGMOD&THR ) printf("{udp_%cterm}{udp_com}(%d) démarré\n", xterm, index); /* 9.2. On signale que ce "manager" est maintenant actif */ activeUDPManagers[index] = 1; }else if( DEBUGMOD&THR ) printf("{udp_%cterm} Aucun thread UDP libre!\n", xterm); } /* [n] On ferme la SOCKET d'écoute globale ==========================================================*/ printf("{udp_%cterm} FERMETURE SOCKET D'ECOUTE UDP!\n", xterm); close(SOCKET); return NULL; } /* Gestion d'une connexion PLANE * * @THREADABLE_SOCKET 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("[main][TCP_LISTEN_THREAD][COM_THREAD] READ = %d\n", read); break; } /* 3. On désérialise la requête*/ printf("[main][TCP_LISTEN_THREAD][COM_THREAD] PLANE 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("[main][UDP_LISTEN_THREAD][COM_THREAD][%d] libéré\n", index); pthread_exit(NULL); } /* Gestion d'une connexion TERMINAL * * @THREADABLE_SOCKET 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* manageTerminal(void* THREADABLE_SOCKET){ /* [1] Initialisation des variables =========================================================*/ int read; // compteur struct sockaddr_in clientInfo; socklen_t len; int UDP_SOCKET = (intptr_t) THREADABLE_SOCKET; // Socket client char request[MAX_BUF_LEN]; // Requête // char response[MAX_BUF_LEN]; // Réponse do{ printf("{udp_x-term}{udp_com} waiting for terminal request\n"); /* [2] Récupération de la requête =========================================================*/ /* 1. On lit sur la socket */ len = sizeof(struct sockaddr_in); read = recvfrom(UDP_SOCKET, request, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len); /* 2. Si erreur reception */ if( DEBUGMOD&BUF ) printf("{udp_x-term}{udp_com} READ = %d\n", read); if( read < 0 ) continue; /* 3. On désérialise la requête*/ printf("{udp_x-term}{udp_com} TERMINAL Request(%d bytes) : '%s'\n", read, request); /* [3] Gestion de la requête =========================================================*/ /* [4] Envoi reponse =========================================================*/ strcpy(request+strlen(request), "-bla\0"); send(UDP_SOCKET, request, strlen(request), 0); }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_UDP_THR ; i++ ) if( UDPManagers[i] == pthread_self() ){ index = i; break; } /* 2. On met à jour "activeManagers" */ if( index != -1 ) activeUDPManagers[index] = 0; /* 3. On arrête le THREAD */ if( DEBUGMOD&THR ) printf("{udp_x-term}{udp_com}(%d) libéré\n", index); pthread_exit(NULL); }