diff --git a/central-manager/central-manager.c b/central-manager/central-manager.c
index 586c36f..a2c3845 100644
--- a/central-manager/central-manager.c
+++ b/central-manager/central-manager.c
@@ -5,26 +5,32 @@
 * @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 ferme la SOCKET d'écoute globale
+*   [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 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_listen}             démarré\n");
+	if( DEBUGMOD&THR ) printf("{tcp_listn}              démarré\n");
 
 	/* (2) Ecoute UDP multicast */
 	// pthread_create(&listenManagers[1], NULL, LISTEN_UDP, (void*)(intptr_t) TCP_);
@@ -44,9 +50,11 @@ int main(int argc, char* argv[]){
 	for( char i = 0 ; i < 4 ; i++ )
 		pthread_join(listenManagers[(int)i], NULL);
 
-	/* [3] On ferme la SOCKET d'écoute globale
+
+	/* [3] On libère les variables globales
 	==========================================================*/
-	printf("FERMETURE DE TOUTES LES CONNECTIONS!\n");
+	free(data);
+	free(update);
 }
 
 
@@ -64,13 +72,15 @@ int main(int argc, char* argv[]){
 *   [4] On ferme la SOCKET d'écoute TCP globale
 *
 */
-void* LISTEN_TCP(){
+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
@@ -78,19 +88,19 @@ void* LISTEN_TCP(){
 
 	/* [1] On démarre le SERVEUR TCP d'écoute globale
 	==========================================================*/
-	if( DROP_TCP_SERVER(TCP_LIST, &LISTENSOCK) < 0 ){
+	if( DROP_TCP_SERVER(TCP_PORT, &LISTENSOCK) < 0 ){
 
-		if( DEBUGMOD&SCK ) printf("{tcp_listen}             Erreur création socket d'écoute\n");
+		if( DEBUGMOD&SCK ) printf("{tcp_listn}              Erreur création socket d'écoute\n");
 
 		// On ferme la SOCKET d'écoute globale
-		printf("{tcp_listen}             FERMETURE SOCKET D'ECOUTE TCP!\n");
+		printf("{tcp_listn}              FERMETURE SOCKET D'ECOUTE TCP!\n");
 		close(LISTENSOCK);
 
 		return NULL;
 	}
 
 
-	printf("{tcp_listen}             Port écoute: %d\n", TCP_LIST);
+	printf("{tcp_listn}              port: %d\n", TCP_PORT);
 
 
 
@@ -107,7 +117,7 @@ void* LISTEN_TCP(){
 
 		/* 3. Si erreur, on attend une nouvelle connection */
 		if( CLIENT_SOCKET < 0 ){
-			if( DEBUGMOD&SCK ) printf("{tcp_listen}             accept: Erreur connection\n");
+			if( DEBUGMOD&SCK ) printf("{tcp_listn}              accept: Erreur connection\n");
 			break;
 		}
 
@@ -121,13 +131,13 @@ void* LISTEN_TCP(){
 			/* 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);
+			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_listen}             Aucun thread libre\n");
+			if( DEBUGMOD&THR ) printf("{tcp_listn}              Aucun thread libre\n");
 
 	}
 
@@ -140,7 +150,7 @@ void* LISTEN_TCP(){
 
 	/* [4] On ferme la SOCKET d'écoute globale
 	==========================================================*/
-	printf("{tcp_listen}             FERMETURE SOCKET D'ECOUTE TCP!\n");
+	printf("{tcp_listn}              FERMETURE SOCKET D'ECOUTE TCP!\n");
 	close(LISTENSOCK);
 
 	return NULL;
@@ -159,9 +169,14 @@ void* LISTEN_TCP(){
 *   [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é)
+*       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){
@@ -183,6 +198,7 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 	// 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 ){
@@ -196,7 +212,7 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 		return NULL;
 	}
 
-	printf("{udp_%cterm}              Listen Port: %d\n", xterm, UDP_PORT);
+	printf("{udp_%cterm}              port: %d\n", xterm, UDP_PORT);
 
 
 
@@ -223,15 +239,19 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 
 		if( DEBUGMOD&SCK ) printf("{udp_%cterm}              '%s' connecté\n", xterm, client_ip);
 
-		/* 4. On parse la requête */
+
+
+		/* [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);
 
-		/* 5 Si on veut un port de communicatin */
+		/* 2. Si on veut un port de communicatin */
 		if( request.flags&BINDHEAD_PRT ){
 
-			/* 5.1 On bind une socket sur un port random */
+			/* 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);
@@ -245,7 +265,8 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 
 		}
 
-		/* 5.2 Si on veut on port de communication */
+
+		/* 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 */
@@ -268,7 +289,8 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 		}
 
 
-		/* 8. On envoie la réponse */
+		/* [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));
@@ -283,19 +305,21 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 
 
 
-		/* 9. On cherche un "manager" libre (inactif) */
+		/* [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; }
 
-		// si on a trouvé un "manager" libre
+		/* 2. si on a trouvé un "manager" libre */
 		if( index != -1 ){
 
-			/* 9.1. On lance un thread pour le traitement de ce client */
+			/* 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);
 
-			/* 9.2. On signale que ce "manager" est maintenant actif */
+			/* 2.2. On signale que ce "manager" est maintenant actif */
 			activeUDPManagers[index] = 1;
 
 		}else
@@ -326,65 +350,117 @@ void* LISTEN_UDP(void* THREADABLE_PORT){
 *
 * @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)
+* @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 récupère le rang dans les "managers"
-* 	2. On met à jour "activeManagers"
-* 	3. On arrête le THREAD
+* 	1. On met à jour "activeManagers"
+* 	2. On arrête le THREAD
 *
 */
 void* managePlane(void* THREADABLE_SOCKET){
 
 	/* [1] Initialisation des variables
 	=========================================================*/
-	int read; // compteur
+	/* 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
-	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;
+	/* 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; }
 
-	/* 2. On met à jour "activeManagers" */
+
+
+	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;
 
-	/* 3. On arrête le THREAD */
-	if( DEBUGMOD&THR ) printf("[main][UDP_LISTEN_THREAD][COM_THREAD][%d] libéré\n", index);
+	/* 2. On arrête le THREAD */
+	if( DEBUGMOD&THR ) printf("{tcp_com}(%d)          libéré\n", index);
 	pthread_exit(NULL);
 }
 
diff --git a/central-manager/central-manager.h b/central-manager/central-manager.h
index 6c8888b..d4d4308 100644
--- a/central-manager/central-manager.h
+++ b/central-manager/central-manager.h
@@ -8,7 +8,7 @@
 
 
 /* headers */
-void* LISTEN_TCP();
+void* LISTEN_TCP(void* THREADABLE_PORT);
 void* LISTEN_UDP(void* THREADABLE_PORT);
 void* managePlane(void* THREADABLE_SOCKET);
 void* manageTerminal(void* THREADABLE_SOCKET);
@@ -31,3 +31,12 @@ static int activeTCPManagers[MAX_TCP_THR] = {0}; // contiendra les THREADS TCP a
 // VARIABLES THREADS CONNECTION UDP
 static pthread_t UDPManagers[MAX_UDP_THR];       // contiendra les THREADS UDP
 static int activeUDPManagers[MAX_UDP_THR] = {0}; // contiendra les THREADS UDP actifs
+
+// ENREGISTREMENT DES DONNEES AVIONS
+struct planeIndexStruct{
+    unsigned int data;
+    unsigned int update;
+} planeIndex;
+
+struct plane* data;
+struct plane* update;
\ No newline at end of file
diff --git a/central-manager/install/install.sh b/central-manager/install/install.sh
old mode 100644
new mode 100755
diff --git a/central-manager/install/run_cterm.sh b/central-manager/install/run_cterm.sh
new file mode 100755
index 0000000..0c23fd7
--- /dev/null
+++ b/central-manager/install/run_cterm.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo -ne "\x3\x0\x0" | nc -u localhost 4446;
diff --git a/central-manager/install/run_plane_request.sh b/central-manager/install/run_plane_request.sh
new file mode 100755
index 0000000..b3bc3f1
--- /dev/null
+++ b/central-manager/install/run_plane_request.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo -ne "abcdef\x1\x0\x0\x0\x2\x0\x0\x0\x3\x0\x0\x0\x4\x0\x0\x0\x5\x0\x0\x0" | nc localhost 20556;
diff --git a/central-manager/install/run_vterm.sh b/central-manager/install/run_vterm.sh
new file mode 100755
index 0000000..efdef99
--- /dev/null
+++ b/central-manager/install/run_vterm.sh
@@ -0,0 +1,3 @@
+#!/bin/bash
+
+echo -ne "\x3\x0\x0" | nc -u localhost 4445;
diff --git a/central-manager/install/uninstall.sh b/central-manager/install/uninstall.sh
old mode 100644
new mode 100755
diff --git a/central-manager/lib/data.h b/central-manager/lib/data.h
index 40a9afd..1207e8c 100644
--- a/central-manager/lib/data.h
+++ b/central-manager/lib/data.h
@@ -6,13 +6,14 @@
     #define TERMREQ_SPD 0x04
     #define TERMREQ_ALT 0x08
 
+    #define PLANE_LEN     ( sizeof(char)*6+sizeof(int)*5 )
     struct plane{
         char code[6];
         int x;
         int y;
         int z;
         int cap;
-        int speed;
+        int spd;
     };
 
     struct term_req{
@@ -27,10 +28,10 @@
     };
 
 
+    #define BINDHDR_LEN     ( sizeof(char)+sizeof(unsigned short) )
     #define BINDHEAD_CTL    0x01
     #define BINDHEAD_PRT    0x02
 
-    #define BINDHDR_LEN     sizeof(char)+sizeof(unsigned short)
     struct bind_header{
         char flags;
         unsigned short port;
diff --git a/central-manager/lib/network/tcp/server.c b/central-manager/lib/network/tcp/server.c
index d38cfeb..bf80aff 100644
--- a/central-manager/lib/network/tcp/server.c
+++ b/central-manager/lib/network/tcp/server.c
@@ -23,7 +23,7 @@ int DROP_TCP_SERVER(const int pPort, int* pListenSock){
     =======================================================*/
     *pListenSock = socket(AF_INET, SOCK_STREAM, 0);
 
-    if( DEBUGMOD&SCK ) printf(" * [drop_tcp_server]     socket: %d\n", *pListenSock);
+    if( DEBUGMOD&SCK&HDR ) printf(" * [drop_tcp_server]     socket: %d\n", *pListenSock);
 
     // si erreur
     if( *pListenSock < 0 ) return -1;
@@ -44,7 +44,7 @@ int DROP_TCP_SERVER(const int pPort, int* pListenSock){
     =======================================================*/
 	STATUS = bind(*pListenSock, (struct sockaddr*) &addr, sizeof(addr));
 
-    if( DEBUGMOD&SCK ) printf(" * [drop_tcp_server]     bind: %d\n", STATUS);
+    if( DEBUGMOD&SCK&HDR ) printf(" * [drop_tcp_server]     bind: %d\n", STATUS);
 
     // si erreur
     if( STATUS < 0 ) return -1;
@@ -54,7 +54,7 @@ int DROP_TCP_SERVER(const int pPort, int* pListenSock){
     =======================================================*/
     STATUS = listen(*pListenSock, MAX_TCP_THR);
 
-    if( DEBUGMOD&SCK ) printf(" * [drop_tcp_server]     listen: %d\n", STATUS);
+    if( DEBUGMOD&SCK&HDR ) printf(" * [drop_tcp_server]     listen: %d\n", STATUS);
 
     // si erreur
     if( STATUS < 0 ) return -1;
diff --git a/central-manager/lib/network/udp/server.c b/central-manager/lib/network/udp/server.c
index 8438f40..32b8ea3 100644
--- a/central-manager/lib/network/udp/server.c
+++ b/central-manager/lib/network/udp/server.c
@@ -22,7 +22,7 @@ int DROP_UDP_SERVER(const int pPort, int* pListenSock, struct sockaddr_in* pInfo
     =======================================================*/
     *pListenSock = socket(AF_INET, SOCK_DGRAM, 0);
 
-    if( DEBUGMOD&SCK ) printf(" * [drop_udp_server]     socket: %d\n", *pListenSock);
+    if( DEBUGMOD&SCK&HDR ) printf(" * [drop_udp_server]     socket: %d\n", *pListenSock);
 
     // si erreur
     if( *pListenSock < 0 ) return -1;
@@ -43,7 +43,7 @@ int DROP_UDP_SERVER(const int pPort, int* pListenSock, struct sockaddr_in* pInfo
     =======================================================*/
 	STATUS = bind(*pListenSock, (struct sockaddr*) pInfo, sizeof(struct sockaddr_in));
 
-    if( DEBUGMOD&SCK ) printf(" * [drop_udp_server]     bind: %d\n", STATUS);
+    if( DEBUGMOD&SCK&HDR ) printf(" * [drop_udp_server]     bind: %d\n", STATUS);
 
     // si erreur
     if( STATUS < 0 ) return -1;