xdrm-brackets
/
sysdis-project
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

update

This commit is contained in:
xdrm-brackets 2017-04-07 20:25:53 +02:00
parent b751266152
commit 0dc72353cd
10 changed files with 177 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

224
central-manager/central-manager.c
View File

@ -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);
}

11
central-manager/central-manager.h
View File

@ -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;

0
central-manager/install/install.sh Normal file → Executable file
View File

3
central-manager/install/run_cterm.sh Executable file
View File

@ -0,0 +1,3 @@
#!/bin/bash
echo -ne "\x3\x0\x0" | nc -u localhost 4446;

3
central-manager/install/run_plane_request.sh Executable file
View File

@ -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;

3
central-manager/install/run_vterm.sh Executable file
View File

@ -0,0 +1,3 @@
#!/bin/bash
echo -ne "\x3\x0\x0" | nc -u localhost 4445;

0
central-manager/install/uninstall.sh Normal file → Executable file
View File

5
central-manager/lib/data.h
View File

@ -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;

6
central-manager/lib/network/tcp/server.c
View File

@ -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;

4
central-manager/lib/network/udp/server.c
View File

@ -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;