#include "central-manager.h" /* * * @argv : {0:program name} * * @history * [0] Initialisation des variables globales * [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 libère les variables 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"); printf("**** Execution tree\n"); /* [0] Initialisation des variables globales =========================================================*/ data = (struct plane*) malloc( 0 ); update = (struct plane*) malloc( 0 ); /* [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_listn} 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 libère les variables globales ==========================================================*/ free(data); free(update); } /* 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(void* THREADABLE_PORT){ /* [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 int TCP_PORT = (intptr_t) THREADABLE_PORT; // Port serveur // 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("{tcp_listn} Erreur création socket d'écoute\n"); // On ferme la SOCKET d'écoute globale printf("{tcp_listn} FERMETURE SOCKET D'ECOUTE TCP!\n"); close(LISTENSOCK); return NULL; } printf("{tcp_listn} 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("{tcp_listn} 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_listn}{com}(%d) démarré\n", index); /* 6. On signale que ce "manager" est maintenant actif */ activeTCPManagers[index] = 1; }else if( DEBUGMOD&THR ) printf("{tcp_listn} 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_listn} 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 * 1. On parse la requête * 2. Si demande de socket de communication * 1. Création socket port random * 2. On récupère le port en question * 3. On envoie la réponse * [4] On envoie la réponse * [5] On démarre un thread de gestion * [N] On ferme la SOCKET d'écoute globale * */ 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} 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); /* [3] Gestion de la requête =========================================================*/ /* 1. 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); /* 2. Si on veut un port de communicatin */ if( request.flags&BINDHEAD_PRT ){ /* 2.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; } } /* 2.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); } } /* [4] Envoi de 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); /* [5] On démarre la tache sur un thread dédié =========================================================*/ /* 1. On cherche un "manager" libre (inactif) */ for( i = 0 ; i < MAX_UDP_THR ; i++ ) if( activeUDPManagers[i] == 0 ){ index = i; break; } /* 2. si on a trouvé un "manager" libre */ if( index != -1 ){ /* 2.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); /* 2.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 * @loop * (2) Attente de requête * (3) Gestion de la requête * (4) Envoi de la réponse * [5] On libère la mémoire * [6] Fermeture de la connection (SOCKET) * [n] Arrêt du THREAD * 1. On met à jour "activeManagers" * 2. On arrête le THREAD * */ void* managePlane(void* THREADABLE_SOCKET){ /* [1] Initialisation des variables =========================================================*/ /* 1. Variables utiles */ int read, i, index, pindex; // compteurs char buffer[MAX_BUF_LEN]; // buffer struct plane data; // données de l'avion /* 2. On récupère la socket */ int TCP_SOCKET = (intptr_t) THREADABLE_SOCKET; // Socket client /* 3. On récupère le rang du thread parmi les "managers" */ index = -1; for( i = 0 ; i < MAX_TCP_THR ; i++ ) if( TCPManagers[i] == pthread_self() ){ index = i; break; } while( 1 ){ /* (2) Récupération de la requête ---------------------------------------------------------*/ /* 1. On lit sur la socket */ read = recv(TCP_SOCKET, buffer, MAX_BUF_LEN, 0); /* 2. Si erreur reception */ if( read < PLANE_LEN ){ if( DEBUGMOD&BUF ) printf("{tcp_com}(%d) read: %d (expected: %d)\n", index, read, (int) PLANE_LEN); continue; } /* 3. On parse la requête*/ memcpy(&data.code, buffer+sizeof(char)*0+sizeof(int)*0, sizeof(char)*6); memcpy(&data.x, buffer+sizeof(char)*6+sizeof(int)*0, sizeof(int)); memcpy(&data.y, buffer+sizeof(char)*6+sizeof(int)*1, sizeof(int)); memcpy(&data.z, buffer+sizeof(char)*6+sizeof(int)*2, sizeof(int)); memcpy(&data.spd, buffer+sizeof(char)*6+sizeof(int)*4, sizeof(int)); memcpy(&data.cap, buffer+sizeof(char)*6+sizeof(int)*3, sizeof(int)); printf("{tcp_com}(%d) received: plane_req{code = '%6s'; x = %d; y = %d; z = %d; cap = %d; spd = %d}\n", index, data.code, data.x, data.y, data.z, data.cap, data.spd); /* (3) Gestion de la requête -> enregistrement ---------------------------------------------------------*/ pindex = -1; /* 1. On regarde si l'avion existe */ for( i = 0 ; i < planeIndex.data ; i++ ) // Si on trouve le meme code, on garde l'indice if( strcmp(data[i].code, data.code) == 0 ){ pindex = i; break; } /* 2. Si l'avion est nouveau -> on l'enregistre */ if( pindex == -1 ){ index = planeIndex.data; // On ajoute une entrée à data data = (struct plane*) realloc(data, sizeof(struct plane)*planeIndex.data); planeIndex.data++; } /* 3. On met à jour les données*/ memcpy(&plane[index], &data, sizeof(struct plane)); /* (4) Envoi de la réponse ---------------------------------------------------------*/ } /* [5] On libère la mémoire =========================================================*/ /* [6] Fermeture de la connection (SOCKET) =========================================================*/ printf("{tcp_com}(%d) Fermeture de la socket de communication!\n", index); close(TCP_SOCKET); /* [n] Arrêt du THREAD ============================================================================*/ /* 1. On met à jour "activeManagers" */ if( index != -1 ) activeTCPManagers[index] = 0; /* 2. On arrête le THREAD */ if( DEBUGMOD&THR ) printf("{tcp_com}(%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); }