Gestion viewTerm fonctionnel [todo] gestion envoi en plusieurs fois

central-manager/central-manager.c

@@ -298,7 +298,7 @@ void* LISTEN_UDP(void* THREADABLE_ARGS){
 			/* 2.1. On lance un thread pour le traitement de ce client */
 			pthread_create(&UDPManagers[index], NULL, arg->handler, (void*) &thread_args);
 
-			if( DEBUGMOD&THR ) printf("{%s}{udp_com}(%d)  démarré\n", entity, index);
+			if( DEBUGMOD&THR ) printf("{%s}{com}(%d)      démarré\n", entity, index);
 
 			/* 2.2. On signale que ce "manager" est maintenant actif */
 			activeUDPManagers[index] = 1;

central-manager/lib/local/handler.c

@@ -188,10 +188,13 @@ void* managePlane(void* THREADABLE_ARGS){
 *
 * @history
 * [1] Initialisation des variables
-* [2] Récupération de la requête
+*
-* [3] Traitement de la requête
+* @loop
-* [4] Création de la réponse
+*   [2] Récupération des données
-* [5] Envoi de la réponse
+*   [3] Construction de la requête
+*   [4] Envoi de la requête
+*   [5] Timeout
+*
 * [6] On vide les buffers
 * [7] Fermeture de la connection (SOCKET)
 * [n] Arrêt du THREAD
@@ -204,60 +207,103 @@ void* manageViewTerm(void* THREADABLE_ARGS){
 
 	/* [1] Initialisation des variables
 	=========================================================*/
-	int read; // compteur
+	/* 1. Initialisation des variables */
 	struct sockaddr_in clientInfo;
 	socklen_t          len;
-	char request[MAX_BUF_LEN]; // Requête
+	char               loop = 1;
-	// char response[MAX_BUF_LEN]; // Réponse
+	int                count, /*to_send, */sent; // compteurs d'envoi
+	int                i, index = -1;        // Compteurs globaux
+	char               buffer[MAX_BUF_LEN];  // Buffer d'envoi
+	struct term_res    request;              // Requête
 
 	/* 2. On récupère les arguments */
 	struct handler_arg* arg = THREADABLE_ARGS;
 
+	/* 3. On récupère le rang dans les "managers" */
+	for( i = 0 ; i < MAX_UDP_THR ; i++ )
+		if( arg->managers[i] == pthread_self() ){ index = i; break; }
+
+	printf("{udp_vterm}{com}(%d)      starting terminal routine\n", index);
 
 
-	do{
+	/* 4. Attente d'un client */
-
-		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(arg->socket, request, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len);
+	if( recvfrom(arg->socket, buffer, MAX_BUF_LEN*sizeof(char), 0, (struct sockaddr*) &clientInfo, &len) < 0 ){
+		printf("{udp_vterm}{com}(%d)      No terminal detected, exiting\n", index);
+		loop = 0;
+	}
 
-		/* 2. Si erreur reception */
-		if( DEBUGMOD&BUF ) printf("{udp_x-term}{udp_com} READ = %d\n", read);
 
-		if( read < 0 )
+	while( loop ){
-			continue;
 
-		/* 3. On désérialise la requête*/
+		/* [2] Récupération des données
-		printf("{udp_x-term}{udp_com} TERMINAL Request(%d bytes) : '%s'\n", read, request);
-
-		/* [3] Gestion de la requête
 		=========================================================*/
+		/* 1. On initialise les variables utiles */
+		request.flags = TERMREQ_FBK;
+		request.n = arg->sgca->n;
+
+		free(request.data);
+		request.data  = malloc( request.n * sizeof(struct plane) + 1 );
+
+		/* 2. On récupère la liste des avions */
+		for( i = 0 ; i < request.n ; i++ )
+			memcpy(&request.data[i], &arg->sgca->data[i], sizeof(struct plane));
 
 
-		/* [4] Envoi reponse
+
+		/* [3] Construction de la requête
 		=========================================================*/
-		strcpy(request+strlen(request), "-bla\0");
+		/* 1. Initialisation du buffer */
-		send(arg->socket, request, strlen(request), 0);
+		bzero(buffer, MAX_BUF_LEN*sizeof(char));
+		count = 0;
+
+		/* 2. Copie des données globales */
+		memcpy(buffer+count, &request.flags, sizeof(char)); count += sizeof(char);
+		memcpy(buffer+count, &request.n,     sizeof(char)); count += sizeof(char);
+
+		/* 3. Copie des données des avions */
+		for( i = 0 ; i < request.n ; i++ ){
+			memcpy(buffer+count, &request.data[i].code, sizeof(char)*6 ); count += sizeof(char)*6;
+			memcpy(buffer+count, &request.data[i].x,    sizeof(int)    ); count += sizeof(int);
+			memcpy(buffer+count, &request.data[i].y,    sizeof(int)    ); count += sizeof(int);
+			memcpy(buffer+count, &request.data[i].z,    sizeof(int)    ); count += sizeof(int);
+			memcpy(buffer+count, &request.data[i].cap,  sizeof(int)    ); count += sizeof(int);
+			memcpy(buffer+count, &request.data[i].spd,  sizeof(int)    ); count += sizeof(int);
+		}
 
 
-	}while( 0 );
+		/* [4] Envoi de la requête
+		=========================================================*/
+		/* 1. Gestion de l'envoi en plusieurs requêtes */
+
+		/* 2. Envoi */
+
+		len = sizeof(struct sockaddr_in);
+		sent = sendto(arg->socket, buffer, count/sizeof(char), 0, (struct sockaddr*) &clientInfo, len);
+
+		/* 3. Gestion erreur */
+		if( sent <= 0 ){
+			printf("{udp_vterm}{com}(%d)      Unable to send data\n", index);
+			break;
+		}
+
+
+		/* [5] Timeout
+		=========================================================*/
+		sleep(PUBL_TIMEOUT);
+
+	}
+
 
 	/* [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( arg->managers[i] == pthread_self() ){ index = i; break; }
 
 	/* 2. On met à jour "activeManagers" */
 	if( index != -1 )
 		arg->activeManagers[index] = 0;
 
 	/* 3. On arrête le THREAD */
-	if( DEBUGMOD&THR ) printf("{udp_x-term}{udp_com}(%d) libéré\n", index);
+	if( DEBUGMOD&THR ) printf("{udp_vterm}{com}(%d) libéré\n", index);
 	pthread_exit(NULL);
 }
 

central-manager/lib/local/middleware.c

@@ -102,7 +102,7 @@ int multicastTerminal(struct middleware_arg* arg){
     }else{
         strcpy(request.addr, SERV_HOST);
         request.port = comInfo.sin_port;
-        if( DEBUGMOD&SCK ) printf("{%s}{udp_com}     socket opened on %s:%d\n", arg->entity, request.addr, ntohs(request.port));
+        if( DEBUGMOD&SCK ) printf("{%s}{com}         socket opened on %s:%d\n", arg->entity, request.addr, ntohs(request.port));
     }