sysdis-project/sgca/lib/local/handler.c

/**************************
*   Handler Dependency    *
***************************
* Designed & Developed by *
*     Adrien Marquès      *
*     <xdrm-brackets>     *
***************************
*   doowap31@gmail.com    *
**************************/
#include "handler.h"






/* Gestion d'une connexion PLANE
*
* @THREADABLE_SOCKET<void*>			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 notifie que l'avion est déconnecté (crash)
* [6] On libère la mémoire
* [7] 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_ARGS){

	/* [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
	int          SOCKET;                 // Copie de la socket (évite les conflits de références)
	char         tmpFlags;


	/* 2. On récupère les arguments */
	struct handler_arg* arg = THREADABLE_ARGS;
	memcpy(&SOCKET, &arg->socket, sizeof(int));
	if( DEBUGMOD&HDR ) printf("===== managePlane(%p, %p, %d, %p) =====\n", (void*) arg->TCPManagers, (void*) arg->activeTCPManagers, arg->socket, (void*) arg->sgca);


	/* 3. On récupère le rang du thread parmi les "managers" */
	index = -1;
	for( i = 0 ; i < MAX_TCP_THR ; i++ )
		if( arg->TCPManagers[i] == pthread_self() ){ index = i; break; }

	// Erreur de thread
	if( index == -1 ){
		if( DEBUGMOD&THR ) printf("{tcp_com}(%d)             Unknown thread index. Aborting\n", index);
		pthread_exit(NULL);
	}


	pindex = -1; // on ne connait pas encore l'avion

	while( 1 ){



		/* (2) Récupération de la requête
		---------------------------------------------------------*/
		/* 1. On lit sur la socket */
		read = recv(SOCKET, buffer, MAX_BUF_LEN, 0);

		/* 2.1. Si erreur reception (-1:erreur, 0:fermeture client propre) */
		if( read <= 0 ){
			if( DEBUGMOD&BUF ) printf("{tcp_com}(%d)             Error receiving (%d), must exit thread\n", index, read);
			break;
		}

		/* 2.2. Si message trop court */
		if( read != PLANE_LEN+1 ){
			if( DEBUGMOD&BUF ) printf("{tcp_com}(%d)             Error receiving (%d bytes, but %d expected)\n", index, read, (int) (PLANE_LEN+1) );
			continue;
		}


		/* 3. On parse la requête (indianness: network order) */
		memcpy(&tmpFlags,  buffer+sizeof(char)*0+sizeof(int)*0, sizeof(char)   );
		memcpy(&data.code, buffer+sizeof(char)*1+sizeof(int)*0, sizeof(char)*6 );
		memcpy(&data.x,    buffer+sizeof(char)*7+sizeof(int)*0, sizeof(int)    );
		memcpy(&data.y,    buffer+sizeof(char)*7+sizeof(int)*1, sizeof(int)    );
		memcpy(&data.z,    buffer+sizeof(char)*7+sizeof(int)*2, sizeof(int)    );
		memcpy(&data.spd,  buffer+sizeof(char)*7+sizeof(int)*4, sizeof(int)    );
		memcpy(&data.cap,  buffer+sizeof(char)*7+sizeof(int)*3, sizeof(int)    );

		/* 4. Gestion de l'indianness */
		data.x      = ntohl(data.x);
		data.y      = ntohl(data.y);
		data.z      = ntohl(data.z);
		data.cap    = ntohl(data.cap);
		data.spd    = ntohl(data.spd);
		data.online = 1;



		/* (3) Gestion de la requête -> enregistrement
		---------------------------------------------------------*/
		/* 1. On cherche le rang de l'avion si on l'a pas déja */
		if( pindex <= -1 ){

			/* 2. On regarde si l'avion existe */
			for( i = 0 ; i < arg->sgca->n ; i++ ){

				// Si l'avion existe -> on passe à la suite
				if( strcmp(arg->sgca->unit[i].data.code, data.code) == 0 ){
					pindex = i;
					break;
				}

			}

		}

		/* 3. Création si n'existe pas */
		if( pindex <= -1 ){

			// On ajoute une entrée à data + socket
			pindex                         = arg->sgca->n;
			arg->sgca->n++;
			arg->sgca->unit                = (struct context_unit*) realloc(arg->sgca->unit,   sizeof(struct context_unit)*arg->sgca->n + 1);
			arg->sgca->unit[pindex].socket = SOCKET;
			arg->sgca->unit[pindex].thrId  = 0xf0;
			printf("{tcp_com}(%d)             plane '%s' (#%d) created\n", index, data.code, pindex);

		}

		/* 4. On copie/met à jour les valeurs */
		if( tmpFlags != TERMREQ_OFF ){ // gestion réponse ctrlTerm
			arg->sgca->unit[pindex].flags = tmpFlags;                                    // on met à jour les flags
			while( arg->sgca->unit[pindex].thrId == 0xf0 );                              // on attend le numéro de thread
			printf("{tcp_com}(%d)             Waking up UDP threaad@%d for ctrlTerm response\n", index, arg->sgca->unit[pindex].thrId);
			pthread_kill(arg->UDPManagers[(int)arg->sgca->unit[pindex].thrId], SIGCONT); // on réveille le thread
			arg->sgca->unit[pindex].thrId = 0xf0;                                        // on laisse la place pour qqn d'autre
		}
		memcpy(&arg->sgca->unit[pindex].data, &data, sizeof(struct plane));

		if( DEBUGMOD&COM ) printf("{tcp_com}(%d)             stored (%d)'%s': {x = %d; y = %d; z = %d; cap = %d; spd = %d}\n", index, pindex, arg->sgca->unit[pindex].data.code, arg->sgca->unit[pindex].data.x, arg->sgca->unit[pindex].data.y, arg->sgca->unit[pindex].data.z, arg->sgca->unit[pindex].data.cap, arg->sgca->unit[pindex].data.spd);

	}


	/* [5] On notifie que l'avoin est déconnecté (crash)
	=========================================================*/
	/* 1. On notifie le crash */
	arg->sgca->unit[pindex].data.online = 0;
	arg->sgca->unit[pindex].socket      = -1;


	/* [6] On libère la mémoire
	=========================================================*/


	/* [7] Fermeture de la connection (SOCKET)
	=========================================================*/
	printf("{tcp_com}(%d)             Closing communication socket\n", index);
	close(SOCKET);


	/* [n] Arrêt du THREAD
	============================================================================*/
	/* 1. On met à jour "activeManagers" */
	if( index != -1 )
		arg->activeTCPManagers[index] = 0;

	/* 2. On arrête le THREAD */
	if( DEBUGMOD&THR ) printf("{tcp_com}(%d)             freed\n", index);
	pthread_exit(NULL);
}




/* Gestion d'une connexion TERMINAL
*
* @THREADABLE_SOCKET<void*>			SOCKET de la connexion client
*
* @history
* [1] Initialisation des variables
*
* @loop
*   [2] Récupération des données
*   [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
* 	1. On récupère le rang dans les "managers"
* 	2. On met à jour "activeManagers"
* 	3. On arrête le THREAD
*
*/
void* manageViewTerm(void* THREADABLE_ARGS){

	/* [1] Initialisation des variables
	=========================================================*/
	/* 1. Initialisation des variables */
	struct sockaddr_in clientInfo;
	socklen_t          len;
	char               loop = 1;
	size_t             buflen;
	int                sent;                 // compteurs d'envoi
	int                i, index = -1;        // Compteurs globaux
	char*              buffer   = malloc(1); // Buffer d'envoi
	int                SOCKET;

	/* 2. On récupère les arguments */
	struct handler_arg* arg = THREADABLE_ARGS;
	memcpy(&SOCKET, &arg->socket, sizeof(int));

	/* 3. On récupère le rang dans les "managers" */
	for( i = 0 ; i < MAX_UDP_THR ; i++ )
		if( arg->UDPManagers[i] == pthread_self() ){ index = i; break; }

	printf("{udp_vterm}{com}(%d)      starting terminal routine (rate: %d sec)\n", index, PUBL_TIMEOUT);


	/* 4. Attente d'un client */
	len = sizeof(struct sockaddr_in);
	if( recvfrom(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;
	}

	if( loop ) printf("{udp_cterm}{com}(%d)      Terminal connected\n", index);


	while( loop ){


		/* [2] Récupération des données
		=========================================================*/
		getPlaneData(&buffer, &buflen, arg->sgca);


		/* [3] Envoi de la requête
		=========================================================*/
		/* 2. Envoi */
		len = sizeof(struct sockaddr_in);
		sent = sendto(SOCKET, buffer, buflen + 1, 0, (struct sockaddr*) &clientInfo, len);

		/* 3. Gestion erreur */
		if( sent <= 0 ){
			printf("{udp_vterm}{com}(%d)      Unable to send data\n", index);
			break;
		}


		/* [4] Réception feedback
		=========================================================*/
		/* 1. Réception feedback (0x10) */
		len = sizeof(struct sockaddr_in);
		sent = recvfrom(SOCKET, buffer, 1, 0, (struct sockaddr*) &clientInfo, &len);

		/* 2. Gestion erreur (erreur ou mauvais feedback != 0x10) */
		if( sent <= 0 || buffer[0] != TERMREQ_OFF ){
			printf("{udp_vterm}{com}(%d)      Unable to recv feedback -> exiting\n", index);
			break;
		}


		/* [4] Timeout
		=========================================================*/
		sleep(PUBL_TIMEOUT);

	}


	/* [n] Arrêt du THREAD
	============================================================================*/
	/* 1. On met à jour "activeManagers" */
	if( index != -1 )
		arg->activeUDPManagers[index] = 0;

	/* 2. On ferme la socket + libère la mémoire */
	close(SOCKET);
	free(buffer);


	/* 3. On arrête le THREAD */
	if( DEBUGMOD&THR ) printf("{udp_vterm}{com}(%d)      freed\n", index);
	pthread_exit(NULL);
}





/* Gestion d'une connexion TERMINAL
*
* @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* manageCtrlTerm(void* THREADABLE_ARGS){

	/* [1] Initialisation des variables
	=========================================================*/
	/* 1. Initialisation des variables */
	struct sockaddr_in clientInfo;
	socklen_t          len;
	size_t             dataLen;
	char               loop = 1, update = 0, fbk = 0;
	int                count, last;                   // compteurs d'envoi
	int                i, index = -1;                 // Compteurs globaux
	int                pindex;                        // index of the current plane
	char               buffer[MAX_BUF_LEN];           // Buffer d'envoi
	char*              dataBuffer = malloc(1);
	struct term_req    request;                       // Requête
	char               flags;
	int                SOCKET;
	struct in_addr*    ip = malloc(sizeof(struct in_addr));


	/* 2. On récupère les arguments */
	struct handler_arg* arg = THREADABLE_ARGS;
	memcpy(&SOCKET, &arg->socket, sizeof(int));

	/* 3. On récupère le rang dans les "managers" */
	for( i = 0 ; i < MAX_UDP_THR ; i++ )
		if( arg->UDPManagers[i] == pthread_self() ){ index = i; break; }

	printf("{udp_cterm}{com}(%d)      starting terminal routine\n", index);

	/* 4. Attente d'un client */
	len = sizeof(struct sockaddr_in);
	if( recvfrom(SOCKET, buffer, MAX_BUF_LEN*sizeof(char), 0, (struct sockaddr*) &clientInfo, &len) < 0 ){
		printf("{udp_cterm}{com}(%d)      No terminal detected, exiting\n", index);
		loop = 0;
	}else{
		ip->s_addr = clientInfo.sin_addr.s_addr;
		printf("{udp_cterm}{com}(%d)      Terminal connected from %s:%d\n", index, inet_ntoa(*ip), ntohs(clientInfo.sin_port));
	}

	free(ip);



	while( loop ){

		pindex = -1;

		/* [2] Récupération de la requête
		=========================================================*/
		/* 1. On lit sur la socket */
		len = sizeof(struct sockaddr_in);
		bzero(buffer, sizeof(char)*MAX_BUF_LEN);
		count = recvfrom(SOCKET, buffer, MAX_BUF_LEN, 0, (struct sockaddr*) &clientInfo, &len);

		/* 2. Si erreur reception */
		if( count <= 0 ) // because of timeout or error
			break;

		if( count < TERMREQ_LEN ){
			send(SOCKET, "\0\0", sizeof(char)*2, 0);
			if( DEBUGMOD&BUF ) printf("{udp_cterm}{com}(%d)      Error receiving request\n", index);
			continue;
		}

		/* 3. On désérialise la requête*/
		bzero(&request, sizeof(struct term_req));
		count  = 0;    last = sizeof(char);   memcpy(&request.flags,       buffer+count, last );
		count += last; last = sizeof(char)*6; memcpy(&request.update.code, buffer+count, last );
		count += last; last = sizeof(int);    memcpy(&request.update.x,    buffer+count, last );
		count += last; last = sizeof(int);    memcpy(&request.update.y,    buffer+count, last );
		count += last; last = sizeof(int);    memcpy(&request.update.z,    buffer+count, last );
		count += last; last = sizeof(int);    memcpy(&request.update.cap,  buffer+count, last );
		count += last; last = sizeof(int);    memcpy(&request.update.spd,  buffer+count, last );



		/* [3] Gestion de la requête
		=========================================================*/
		/* 1. On vérifie qu'il y a bien un update demandé (ou DATA) */
		update = ( request.flags&TERMREQ_ALT || request.flags&TERMREQ_CAP || request.flags&TERMREQ_SPD );
		fbk    = request.flags&TERMREQ_FBK;
		if( !( update || fbk ) ){
			send(SOCKET, "\x00\0", sizeof(char)*2, 0);
			if( request.flags != 0 )
				printf("{udp_cterm}{com}(%d)      Invalid flags\n", index);
			continue;
		}

		printf("{udp_cterm}{com}(%d)      Plane req { flags: %d; plane: #%s { z=%d; cap=%d; speed=%d } }\n", index, request.flags, request.update.code, ntohl(request.update.z), ntohl(request.update.cap), ntohl(request.update.spd));

		/* [4] Gestion de la mise à jour de valeurs
		=========================================================*/
		while( update ){

			/* (1) Recherche de l'avion
			---------------------------------------------------------*/
			/* 1. On cherche l'avion par code */
			for( i = 0 ; i < arg->sgca->n ; i++ ){

				/* 2. Si l'avion existe et online -> on passe à la suite */
				if( strcmp(arg->sgca->unit[i].data.code, request.update.code) == 0 && arg->sgca->unit[i].data.online == 1 ){
					pindex = i;
					break;
				}

			}



			/* 3. Si on a pas trouvé -> on quitte l'udpdate */
			if( pindex <= -1 || arg->sgca->unit[pindex].socket <= -1 ){
				printf("{udp_cterm}{com}(%d)      Plane unknown or unreachable, passing\n", index);
				request.flags = TERMREQ_OFF;
				break;
			}

			/* (2) Transfert de la requête à l'avion
			---------------------------------------------------------*/
			/* 1. On prépare la requête */
			bzero(buffer, sizeof(char)*MAX_BUF_LEN);

			/* 2. On remplit le buffer d'envoi */
			count  = 0;    last = sizeof(char); memcpy(buffer+count, &request.flags,      last );
			count += last; last = sizeof(int);  memcpy(buffer+count, &request.update.z,   last );
			count += last; last = sizeof(int);  memcpy(buffer+count, &request.update.cap, last );
			count += last; last = sizeof(int);  memcpy(buffer+count, &request.update.spd, last );
			count += last;

			/* 3. On envoie la requête à l'avion */
			if( send(arg->sgca->unit[pindex].socket, buffer, count/sizeof(char), 0) <= 0 ){
				printf("{udp_cterm}{com}(%d)      Cannot send request to plane\n", index);
				request.flags = TERMREQ_OFF;
				break;
			}


			/* (3) Gestion de la réponse de l'avion
			---------------------------------------------------------*/
			// Attente du flag de réponse
			arg->sgca->unit[pindex].thrId = index;
			sleep(2);
			flags = arg->sgca->unit[pindex].flags; // on récupère les flags
			arg->sgca->unit[pindex].flags = TERMREQ_OFF;  // on reset les flags

			if( flags == TERMREQ_OFF ){
				printf("{udp_cterm}{com}(%d)      Cannot get response from plane %d bytes (%d expected)\n", index, count, (int) PLANE_LEN);
				request.flags = TERMREQ_OFF;
				break;
			}

			printf("{udp_cterm}{com}(%d)      Plane res { flags: %d }\n", index, flags);

			/* 2. Gestion de la validation de l'update */
			if( !(flags&TERMREQ_ALT) && request.flags&TERMREQ_ALT )
				request.flags -= TERMREQ_ALT;

			if( !(flags&TERMREQ_CAP) && request.flags&TERMREQ_CAP )
				request.flags -= TERMREQ_CAP;

			if( !(flags&TERMREQ_SPD) && request.flags&TERMREQ_SPD )
				request.flags -= TERMREQ_SPD;

			/* 3. Si pas de demande des données -> on pré-remplie la requête */
			if( !fbk ){
				dataBuffer    = realloc(dataBuffer, sizeof(char)*2 );
				dataBuffer[0] = request.flags;
				dataBuffer[1] = 0;
				dataLen = 2;
			}

			break;

		}

		if( fbk ){

			/* [5] Données des avions
			=========================================================*/
			/* 1. On récupère les données */
			getPlaneData(&dataBuffer, &dataLen, arg->sgca);

			/* 2. Si update, on mixe les flags */
			if( update )
				dataBuffer[0] |= request.flags;

		}


		/* [6] Réponse au terminal
		=========================================================*/
		printf("{udp_cterm}{com}(%d)      Sending response { flags: %d; n: %d }\n", index, dataBuffer[0], dataBuffer[1]);
		len = sizeof(struct sockaddr_in);
		if( sendto(SOCKET, dataBuffer, dataLen, 0, (struct sockaddr*) &clientInfo, len) < 0 )
			printf("{udp_cterm}{com}(%d)      Cannot answer to terminal\n", index);


	}


	/* [n] Arrêt du THREAD
	============================================================================*/
	/* 1. On met à jour "activeManagers" */
	if( index != -1 )
		arg->activeUDPManagers[index] = 0;

	/* 2. On ferme la socket */
	close(SOCKET);
	free(dataBuffer);

	/* 3. On arrête le THREAD */
	if( DEBUGMOD&THR ) printf("{udp_cterm}{com}(%d)      freed\n", index);
	pthread_exit(NULL);
}




















void getPlaneData(char** pBuffer, size_t* pLen, struct context* pContext){
	/* [1] Initialisation des variables
	=========================================================*/
	/* 1. Initialisation des variables */
	int                count, last, i, nb; // compteurs
	struct term_res    response;               // Requête


	/* [1] Récupération des données
	=========================================================*/
	/* 1. On initialise les variables utiles */
	response.flags = TERMREQ_FBK;
	nb             = pContext->n;
	response.n     = 0; // nombre d'avions online

	response.data  = malloc( nb * sizeof(struct plane) + 1 );

	/* 2. On récupère la liste des avions (network byte order) */
	for( i = 0 ; i < nb ; i++ ){

		memcpy(&response.data[i].code, &pContext->unit[i].data.code, sizeof(char)*6);
		response.data[i].x      = htonl( pContext->unit[i].data.x   );
		response.data[i].y      = htonl( pContext->unit[i].data.y   );
		response.data[i].z      = htonl( pContext->unit[i].data.z   );
		response.data[i].cap    = htonl( pContext->unit[i].data.cap );
		response.data[i].spd    = htonl( pContext->unit[i].data.spd );
		response.data[i].online =        pContext->unit[i].data.online;

		// Incrément du compte si online
		response.n += response.data[i].online;

	}


	/* [3] Construction de la requête
	=========================================================*/
	/* 1. Initialisation du buffer */
	*pBuffer = realloc(*pBuffer, sizeof(char)*2 + PLANE_LEN * response.n + sizeof(char));

	/* 2. Copie des données globales */
	count  = 0;    last = sizeof(char); memcpy(*pBuffer+count, &response.flags, last);
	count += last; last = sizeof(char); memcpy(*pBuffer+count, &response.n,     last);

	/* 3. Copie des données des avions */
	for( i = 0 ; i < nb ; i++ ){

		// Ignore les avions offline
		if( !response.data[i].online )
			continue;

		count += last; last = sizeof(char)*6; memcpy(*pBuffer+count, &response.data[i].code, last);
		count += last; last = sizeof(int);    memcpy(*pBuffer+count, &response.data[i].x,    last);
		count += last; last = sizeof(int);    memcpy(*pBuffer+count, &response.data[i].y,    last);
		count += last; last = sizeof(int);    memcpy(*pBuffer+count, &response.data[i].z,    last);
		count += last; last = sizeof(int);    memcpy(*pBuffer+count, &response.data[i].cap,  last);
		count += last; last = sizeof(int);    memcpy(*pBuffer+count, &response.data[i].spd,  last);
	}

	*pLen = (count+last) / sizeof(char);
	free(response.data);

}