mcy
/
owlps
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[Aggregator] Translation of comments, 72 col.

This commit is contained in:
Matteo Cypriani 2010-07-12 16:34:25 +02:00
parent 1863bd9e9f
commit 417452a7ad
2 changed files with 257 additions and 174 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

58
infrastructure-centred/owlps-aggregator/owlps-aggregator.h
View File

@ -2,62 +2,68 @@
* This file is part of the rtap localisation project. * This file is part of the rtap localisation project.
*/ */
#ifndef _RTAPAGGREGATE_H #ifndef _OWLPS_AGGREGATOR_H_
#define _RTAPAGGREGATE_H #define _OWLPS_AGGREGATOR_H_
#include "../../libowlps/owlps.h" #include "../../libowlps/owlps.h"
#include <confuse.h> #include <confuse.h>
#define DEBUG #define DEBUG
//#define TIMESTAMP // Décommenter pour afficher le timestamp à chaque ligne du fichier de sortie. // Uncomment to output the timestamp on each line of the output file:
//#define TIMESTAMP
/* Arguments & configuration du programme */ /* Arguments & program configuration */
#define OPTIONS "a:c:f:i:k:l:o:p:" // Chaîne pour getopt #define OPTIONS "a:c:f:i:k:l:o:p:" // getopt string
#define DEFAULT_CONFIG_FILE "/usr/local/etc/owlps/owlps-aggregator.conf" #define DEFAULT_CONFIG_FILE "/usr/local/etc/owlps/owlps-aggregator.conf"
#define DEFAULT_AGGREGATE_TIMEOUT 1500 // Timeout d'agrégation (en millisecondes) #define DEFAULT_AGGREGATE_TIMEOUT 1500 // milliseconds
#define DEFAULT_KEEP_TIMEOUT 3000 // Temps que l'on conserve les données dans la liste (en millisecondes) #define DEFAULT_KEEP_TIMEOUT 3000 // milliseconds
#define DEFAULT_CHECK_INTERVAL 500000 // Temps entre deux vérifications de la liste (en micro-secondes) #define DEFAULT_CHECK_INTERVAL 500000 // microseconds
#define POSITIONER_DEFAULT_IP "127.0.0.1" #define POSITIONER_DEFAULT_IP "127.0.0.1"
/* Codes d'erreur */
#define ERR_NO_MESSAGE_RECEIVED 1 // Erreur lors de la lecture sur la socket /* Error codes */
#define ERR_CREATING_SOCKET 2 // Erreur lors de la création de la socket d'écoute #define ERR_NO_MESSAGE_RECEIVED 1 // Error when reading the socket
#define ERR_BAD_USAGE 3 // Mauvais appel au programme #define ERR_CREATING_SOCKET 2 // Erreur when creating listening socket
#define ERR_PARSING_CONFIG_FILE 4 // Erreur lors de la lecture du fichier de configuration #define ERR_BAD_USAGE 3 // Bad program call
#define ERR_PARSING_CONFIG_FILE 4 // Error reading the configuration file
/* Liste chaînée des informations concernant un couple MAC / séquence */ /* Linked list storing data of couples MAC / sequence number */
typedef struct _couple_info_list typedef struct _couple_info_list
{ {
unsigned char ap_mac_addr_bytes[6] ; // Adresse MAC de l'AP émetteur de l'info en octets // MAC address of the data sender (in bytes):
unsigned char antenna_signal_dbm ; // Puissance du signal reçu par l'AP du mobile unsigned char ap_mac_addr_bytes[6] ;
// Signal strength received by the AP from the mobile:
unsigned char antenna_signal_dbm ;
struct _couple_info_list *next ; struct _couple_info_list *next ;
} couple_info_list ; } couple_info_list ;
/* Liste chaînée des couples MAC / séquence */ /* Linked list of the couples MAC / sequence number */
typedef struct _couple_list typedef struct _couple_list
{ {
/* Numéro de séquence de la demande de localisation du mobile */ /* Numéro de séquence de la demande de localisation du mobile */
unsigned char mobile_mac_addr_bytes[6] ; // Adresse MAC du mobile en octets unsigned char mobile_mac_addr_bytes[6] ; // Mobile MAC address (in bytes)
struct timeval request_time ; // Heure de la demande sur le mobile struct timeval request_time ; // Request time on the mobile
/* Données pour la calibration */ /* Calibration data */
float x_position ; float x_position ;
float y_position ; float y_position ;
float z_position ; float z_position ;
DIRECTION direction ; // Orientation de la demande de localisation DIRECTION direction ; // Request orientation
/* Other data */
// Arrival time of the first packet of the couple on the aggregator:
struct timeval start_time ;
couple_info_list *info ; // Data for this couple
/* Autres données */
struct timeval start_time ; // Heure d'arrivée du premier paquet du couple sur le serveur d'agrégation
couple_info_list *info ; // Liste des informations pour ce couple
struct _couple_list *next ; struct _couple_list *next ;
} couple_list ; } couple_list ;
/* En-têtes de fonctions */ /* Function headers */
void initialise_configuration(int argc, char **argv) ; void initialise_configuration(int argc, char **argv) ;
void parse_config_file(int argc, char **argv) ; void parse_config_file(int argc, char **argv) ;
void parse_command_line(int argc, char **argv) ; void parse_command_line(int argc, char **argv) ;
@ -75,4 +81,4 @@ void* monitor_couple_list(couple_list **couples) ;
char* ip_bytes_to_string(unsigned char *ip_binary) ; char* ip_bytes_to_string(unsigned char *ip_binary) ;
void print_usage(void) ; void print_usage(void) ;
#endif #endif // _OWLPS_AGGREGATOR_H_

373
infrastructure-centred/owlps-aggregator/owlps-aggregatord.c
View File

@ -15,39 +15,43 @@ couple_list *couples = NULL ; // Computed data list
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
int ret = 0 ; // Valeur de retour du programme int ret = 0 ; // Program return value
struct sigaction action ; // Structure de mise en place des gestionnaires de signaux struct sigaction action ; // Signal handler structure
pthread_t thread ; // Thread pour la fonction de surveillance de la liste d'informations agrégées pthread_t thread ; // Thread for aggregated data monitoring function
int sockfd ; // Socket d'écoute UDP unsigned int listening_port ;
int sockfd ; // UDP listening socket
program_name = argv[0] ; program_name = argv[0] ;
initialise_configuration(argc, argv) ; initialise_configuration(argc, argv) ;
/* Mise en place des gestionnaires de signaux */ /* Set up signal handlers */
sigemptyset(&action.sa_mask) ; sigemptyset(&action.sa_mask) ;
action.sa_handler = sigint_handler ; action.sa_handler = sigint_handler ;
sigaction(SIGINT, &action, NULL) ; sigaction(SIGINT, &action, NULL) ;
action.sa_handler = sigterm_handler ; action.sa_handler = sigterm_handler ;
sigaction(SIGTERM, &action, NULL) ; sigaction(SIGTERM, &action, NULL) ;
/* Création de la socket UDP */ /* Create UDP socket */
if ((sockfd = create_udp_listening_socket(cfg_getint(cfg, "listening_port"))) < 0) listening_port = cfg_getint(cfg, "listening_port") ;
if ((sockfd = create_udp_listening_socket(listening_port)) < 0)
{ {
fprintf(stderr, "Erreur ! Impossible d'écouter sur le port %ld.\n", cfg_getint(cfg, "listening_port")) ; fprintf(stderr,
"Error! Cannot listen on port %u.\n", listening_port) ;
return ERR_CREATING_SOCKET ; return ERR_CREATING_SOCKET ;
} }
/* Création du thread */ /* Set up thread */
pthread_create(&thread, NULL, (void *) &monitor_couple_list, &couples) ; pthread_create(&thread, NULL,
(void *) &monitor_couple_list, &couples) ;
run = TRUE ; run = TRUE ;
ret = read_loop(sockfd) ; ret = read_loop(sockfd) ;
(void) close(sockfd) ; // Fermeture de la socket (void) close(sockfd) ; // Close socket
free_couple_list(&couples) ; // Nettoyage de la liste free_couple_list(&couples) ; // Clean list
cfg_free(cfg) ; // Nettoyage de la configuration cfg_free(cfg) ; // Clean configuration
printf("%s : fin.\n", argv[0]) ; printf("%s: end.\n", program_name) ;
return ret ; return ret ;
} }
@ -61,7 +65,7 @@ void initialise_configuration(int argc, char **argv)
#ifdef DEBUG #ifdef DEBUG
/* Configuration printing */ /* Configuration printing */
fprintf(stderr, "Configuration :\n") ; fprintf(stderr, "Configuration:\n") ;
cfg_print(cfg, stderr) ; cfg_print(cfg, stderr) ;
#endif // DEBUG #endif // DEBUG
} }
@ -104,7 +108,8 @@ void parse_config_file(int argc, char **argv)
} }
else // If -f isn't found, we use the default config file else // If -f isn't found, we use the default config file
{ {
config_file = malloc((strlen(DEFAULT_CONFIG_FILE) + 1) * sizeof(char)) ; config_file =
malloc((strlen(DEFAULT_CONFIG_FILE) + 1) * sizeof(char)) ;
strcpy(config_file, DEFAULT_CONFIG_FILE) ; strcpy(config_file, DEFAULT_CONFIG_FILE) ;
} }
@ -212,45 +217,54 @@ void check_configuration()
/*
* Reads packets while the program is not stopped.
*/
int read_loop(int sockfd) int read_loop(int sockfd)
{ {
int ret = 0 ; // Return value int ret = 0 ; // Return value
int nread ; // Retour de recvfrom int nread ; // recvfrom return value
struct sockaddr_in client; // Structure pour le client UDP struct sockaddr_in client; // UDP client structure
socklen_t client_len = sizeof(client) ; // Taille du client pour la socket socklen_t client_len = sizeof(client) ; // Size of clients
couple_message message ; // Message lu sur la socket couple_message message ; // Message read on the socket
char *ap_mac_string, *mobile_mac_string ; // Pointeurs pour retour de mac_bytes_to_string() char
char *mobile_ip_string ; *ap_mac_string, // Return pointers for mac_bytes_to_string()
*mobile_mac_string,
*mobile_ip_string ; // and ip_bytes_to_string()
while (run) while (run)
{ {
nread = recvfrom(sockfd, &message, sizeof(message), 0, (struct sockaddr *) &client, &client_len) ; nread = recvfrom(sockfd, &message, sizeof(message), 0,
(struct sockaddr *) &client, &client_len) ;
if (nread <= 0) if (nread <= 0)
{ {
if (run) if (run)
{ {
fprintf(stderr, "Aucun message reçu du client !\n") ; fprintf(stderr, "No message received from client!\n") ;
ret = ERR_NO_MESSAGE_RECEIVED ; ret = ERR_NO_MESSAGE_RECEIVED ;
} }
break ; break ;
} }
ap_mac_string = mac_bytes_to_string(message.ap_mac_addr_bytes) ; ap_mac_string =
mobile_mac_string = mac_bytes_to_string(message.mobile_mac_addr_bytes) ; mac_bytes_to_string(message.ap_mac_addr_bytes) ;
mobile_ip_string = ip_bytes_to_string(message.mobile_ip_addr_bytes) ; mobile_mac_string =
printf("\n\ mac_bytes_to_string(message.mobile_mac_addr_bytes) ;
*** Message reçu du client ***\n\ mobile_ip_string =
\tMAC AP : %s\n\ ip_bytes_to_string(message.mobile_ip_addr_bytes) ;
\tMAC mobile : %s\n\ printf("\n"
\tIP mobile : %s\n\ "*** Message received from client ***\n"
\tNuméro de séquence (heure de la demande) : %llu\n\ "\tAP MAC: %s\n"
\tHeure d'arrivée de la demande de localisation sur l'AP : %llu\n\ "\tMobile MAC: %s\n"
\tSignal : %d dBm\n\ "\tMobile IP: %s\n"
\tPosition X : %f\n\ "\tSequence number (request timestamp): %llu\n"
\tPosition Y : %f\n\ "\tRequest arrival time on the AP: %llu\n"
\tPosition Z : %f\n\ "\tSignal: %d dBm\n"
\tDirection : %hhd\n\ "\tPosition X: %f\n"
", "\tPosition Y: %f\n"
"\tPosition Z: %f\n"
"\tDirection: %hhd\n"
,
ap_mac_string, ap_mac_string,
mobile_mac_string, mobile_mac_string,
mobile_ip_string, mobile_ip_string,
@ -274,7 +288,10 @@ int read_loop(int sockfd)
/* Fonction du thread, qui surveille la liste et envoie les infos au serveur de localisation au bout du timeout */ /*
* Thread function. Monitors the list and sends information to the
* localisation server when the timeout is reached.
*/
void* monitor_couple_list(couple_list **couples) void* monitor_couple_list(couple_list **couples)
{ {
couple_list *couple_ptr, *couple_prev ; couple_list *couple_ptr, *couple_prev ;
@ -282,7 +299,12 @@ void* monitor_couple_list(couple_list **couples)
struct timeval current_time ; struct timeval current_time ;
FILE *fd = NULL ; FILE *fd = NULL ;
char *ap_mac_string ; char *ap_mac_string ;
unsigned long sub ; // Résultat de sub_date(). unsigned long sub ; // sub_date() result
unsigned long aggregate_timeout =
(unsigned long) cfg_getint(cfg, "aggregate_timeout") ;
unsigned long keep_timeout =
(unsigned long) cfg_getint(cfg, "keep_timeout") ;
struct sockaddr_in serv; struct sockaddr_in serv;
struct sockaddr_in client ; struct sockaddr_in client ;
@ -291,14 +313,17 @@ void* monitor_couple_list(couple_list **couples)
couple_info info; couple_info info;
int sockfd; int sockfd;
sockfd = create_udp_sending_socket(cfg_getstr(cfg, "positioner_ip"), cfg_getint(cfg, "positioner_port"), &serv, &client); sockfd = create_udp_sending_socket(cfg_getstr(cfg, "positioner_ip"),
cfg_getint(cfg, "positioner_port"),
&serv, &client) ;
fd = fopen(cfg_getstr(cfg, "output_file"), "a") ; // Ouverture du fichier de sortie en ajout /* Open output file */
if (fd == NULL) // Si ouverture échouée, fd = fopen(cfg_getstr(cfg, "output_file"), "a") ; // We use add mode
if (fd == NULL) // If we failed to open the file,
{ {
perror("Impossible d'ouvrir le fichier de sortie ") ; perror("Cannot open output file") ;
fprintf(stderr, "Redirection de la sortie sur la sortie standard.") ; fprintf(stderr, "Redirecting output to standard output.") ;
fd = stdout ; // on redirige sur stdout fd = stdout ; // we fail back to stdout.
} }
while (run) while (run)
@ -308,28 +333,37 @@ void* monitor_couple_list(couple_list **couples)
couple_info_ptr = NULL ; couple_info_ptr = NULL ;
gettimeofday(&current_time, NULL) ; gettimeofday(&current_time, NULL) ;
while (couple_ptr != NULL) // Parcours de la liste while (couple_ptr != NULL) // Parsing list
{ {
sub = sub_date(couple_ptr->start_time, current_time) ; sub = sub_date(couple_ptr->start_time, current_time) ;
if (couple_ptr->info != NULL) // Si le couple atteint n'a pas déjà été traité // If the couple was not treated already
if (couple_ptr->info != NULL)
{ {
if (sub > (unsigned long) cfg_getint(cfg, "aggregate_timeout")) // Si le timeout est atteint, // If the timeout is reached
if (sub > aggregate_timeout)
{ {
printf("* Timeout dépassé.") ; printf("* Timeout reached.") ;
#ifdef DEBUG #ifdef DEBUG
printf(" sub=%lu > aggregate_timeout=%ld\n", sub, cfg_getint(cfg, "aggregate_timeout")) ; printf(" sub=%lu > aggregate_timeout=%ld\n",
sub, aggregate_timeout) ;
#else // DEBUG #else // DEBUG
putchar('\n') ; putchar('\n') ;
#endif // DEBUG #endif // DEBUG
#ifdef TIMESTAMP #ifdef TIMESTAMP
fprintf(fd, "%llu;", timeval_to_ms(couple_ptr->request_time)) ; // Inscription de la date de la demande (sur le mobile) dans le fichier // Print request mobile timestamp to the output file
fprintf(fd, "%llu;",
timeval_to_ms(couple_ptr->request_time)) ;
#endif // TIMESTAMP #endif // TIMESTAMP
fprintf(fd, "%0.2f;%0.2f;%0.2f;%hhd", couple_ptr->x_position, couple_ptr->y_position, couple_ptr->z_position, couple_ptr->direction) ; // Inscription des infos du couple dans le fichier // Print couple info to the output file
fprintf(fd, "%0.2f;%0.2f;%0.2f;%hhd",
couple_ptr->x_position, couple_ptr->y_position,
couple_ptr->z_position, couple_ptr->direction) ;
memcpy(demande.mobile_mac_addr_bytes, couple_ptr -> mobile_mac_addr_bytes, 6); memcpy(demande.mobile_mac_addr_bytes,
demande.request_time = couple_ptr->request_time; couple_ptr->mobile_mac_addr_bytes, 6) ;
demande.request_time = couple_ptr->request_time ;
demande.nb_couples = 0 ; demande.nb_couples = 0 ;
couple_info_ptr = couple_ptr->info ; couple_info_ptr = couple_ptr->info ;
@ -338,23 +372,30 @@ void* monitor_couple_list(couple_list **couples)
demande.nb_couples++; demande.nb_couples++;
couple_info_ptr = couple_info_ptr->next ; couple_info_ptr = couple_info_ptr->next ;
} }
sendto(sockfd, (void *)&demande, sizeof(request), 0, (struct sockaddr *)&serv, serv_len) ; sendto(sockfd, (void *)&demande, sizeof(request), 0,
(struct sockaddr *)&serv, serv_len) ;
// Send couples to the server and empty the list
couple_info_ptr = couple_ptr->info ; couple_info_ptr = couple_ptr->info ;
while (couple_info_ptr != NULL) // On envoi les couples au serveur et on vide la liste while (couple_info_ptr != NULL)
{ {
// Envoi des infos de l'AP vers le serveur de géolocalisation // Send AP info to the localisation server
memcpy(info.ap_mac_addr_bytes, couple_info_ptr->ap_mac_addr_bytes, 6); memcpy(info.ap_mac_addr_bytes,
info.antenna_signal_dbm = couple_info_ptr->antenna_signal_dbm - 0x100; couple_info_ptr->ap_mac_addr_bytes, 6) ;
sendto(sockfd, (void *)&info, sizeof(couple_info), 0, (struct sockaddr *)&serv, serv_len); info.antenna_signal_dbm =
couple_info_ptr->antenna_signal_dbm - 0x100 ;
sendto(sockfd, (void *)&info, sizeof(couple_info),
0, (struct sockaddr *)&serv, serv_len) ;
// Inscription des infos de l'AP dans le fichier // Print AP info to the output file
ap_mac_string = mac_bytes_to_string(couple_info_ptr->ap_mac_addr_bytes) ; ap_mac_string =
fprintf(fd, ";%s;%d", ap_mac_string, couple_info_ptr->antenna_signal_dbm - 0x100) ; mac_bytes_to_string(couple_info_ptr
->ap_mac_addr_bytes) ;
fprintf(fd, ";%s;%d", ap_mac_string,
couple_info_ptr->antenna_signal_dbm - 0x100) ;
free(ap_mac_string) ; free(ap_mac_string) ;
// Suppression du maillon // Delete couple
couple_info_ptr = couple_info_ptr->next ; couple_info_ptr = couple_info_ptr->next ;
free(couple_ptr->info) ; free(couple_ptr->info) ;
couple_ptr->info = couple_info_ptr ; couple_ptr->info = couple_info_ptr ;
@ -364,74 +405,84 @@ void* monitor_couple_list(couple_list **couples)
} }
} }
else if (sub > (unsigned long) cfg_getint(cfg, "keep_timeout")) // Si le couple a été traité et que le temps de garde est écoulé // If the couple was treated and keep timeout is reached
else if (sub > keep_timeout)
{ {
couple_list *couple_tmp = couple_ptr ; couple_list *couple_tmp = couple_ptr ;
printf("* Délai de garde dépassé.") ; printf("* Keep timeout reached.") ;
#ifdef DEBUG #ifdef DEBUG
printf(" sub=%lu > keep_timeout=%ld\n", sub, cfg_getint(cfg, "keep_timeout")) ; printf(" sub=%lu > keep_timeout=%ld\n",
sub, keep_timeout) ;
#else // DEBUG #else // DEBUG
putchar('\n') ; putchar('\n') ;
#endif // DEBUG #endif // DEBUG
couple_ptr = couple_ptr->next ; couple_ptr = couple_ptr->next ;
if (couple_prev == NULL) // Si on est en tête de liste, // If it is the first couple of the list
*couples = couple_ptr ; // on positionne la tête sur le suivant if (couple_prev == NULL)
else *couples = couple_ptr ; // we shift the head
couple_prev->next = couple_ptr ; // sinon on positionne le suivant du précédent sur le suivant. else // else we put the next of the previous on the next
couple_prev->next = couple_ptr ;
free(couple_tmp) ; free(couple_tmp) ;
continue ; // On saute les instructions pour aller au suivant puisque c'est déjà fait continue ;
} }
// Couple suivant // Next couple
couple_prev = couple_ptr ; couple_prev = couple_ptr ;
couple_ptr = couple_ptr->next ; couple_ptr = couple_ptr->next ;
} }
fflush(NULL) ; fflush(NULL) ;
usleep(cfg_getint(cfg, "check_interval")) ; // On attend avant de vérifier à nouveau usleep(cfg_getint(cfg, "check_interval")) ; // Wait to check again
} }
/* Fermeture du fichier */ /* Close output file */
if (fclose(fd) != 0) if (fclose(fd) != 0)
perror("Erreur lors de la fermeture du fichier de sortie ") ; perror("Error closing output file") ;
return NULL ; return NULL ;
} }
/* Fonction appelée lors de la réception d'un paquet */ /*
* Treats a received packet.
*/
void got_couple_info(couple_list **couples, couple_message message) void got_couple_info(couple_list **couples, couple_message message)
{ {
couple_list *tmp_couple = NULL ; couple_list *tmp_couple = NULL ;
couple_info_list *tmp_info = NULL ; couple_info_list *tmp_info = NULL ;
struct timeval start_time ; // Heure de réception du paquet par l'agrégateur struct timeval start_time ; // Reception time on the aggregator
gettimeofday(&start_time, NULL) ; gettimeofday(&start_time, NULL) ;
/* Initialisation d'un nouveau sous-maillon */ /* Create a new couple */
tmp_info = malloc(sizeof(couple_info_list)) ; tmp_info = malloc(sizeof(couple_info_list)) ;
memcpy(tmp_info->ap_mac_addr_bytes, message.ap_mac_addr_bytes, 6) ; memcpy(tmp_info->ap_mac_addr_bytes, message.ap_mac_addr_bytes, 6) ;
tmp_info->antenna_signal_dbm = message.antenna_signal_dbm ; tmp_info->antenna_signal_dbm = message.antenna_signal_dbm ;
tmp_info->next = NULL ; tmp_info->next = NULL ;
/* Ajout dans la liste */ /* Add it in the list */
tmp_couple = *couples ; tmp_couple = *couples ;
if (*couples == NULL) // Si la liste de couples n'existe pas encore, if (*couples == NULL) // If the couple list does not exist,
{ {
printf("Création de la liste des couples.\n") ; printf("Creating couple list.\n") ;
tmp_couple = malloc(sizeof(couple_list)) ; // on la crée. tmp_couple = malloc(sizeof(couple_list)) ; // create it.
memcpy(tmp_couple->mobile_mac_addr_bytes, message.mobile_mac_addr_bytes, 6) ; memcpy(tmp_couple->mobile_mac_addr_bytes,
if (timeval_to_ms(message.request_time) != 0) // Paquet explicite message.mobile_mac_addr_bytes, 6) ;
tmp_couple->request_time = message.request_time ; // Heure d'émission par le mobile if (timeval_to_ms(message.request_time) != 0) // Explicit packet
else // Paquet implicite // Transmission time on the mobile:
tmp_couple->request_time = message.start_time ; // Heure de réception par l'AP tmp_couple->request_time = message.request_time ;
tmp_couple->start_time = start_time ; // Enregistrement de la date locale de l'agrégateur et non de la date de réception de la demande sur l'AP else // Implicit packet
// Reception time on the AP:
tmp_couple->request_time = message.start_time ;
// Save locale time on the aggregator (not the reception time
// on the AP):
tmp_couple->start_time = start_time ;
tmp_couple->x_position = message.x_position ; tmp_couple->x_position = message.x_position ;
tmp_couple->y_position = message.y_position ; tmp_couple->y_position = message.y_position ;
tmp_couple->z_position = message.z_position ; tmp_couple->z_position = message.z_position ;
@ -440,39 +491,51 @@ void got_couple_info(couple_list **couples, couple_message message)
tmp_couple->info = tmp_info ; tmp_couple->info = tmp_info ;
*couples = tmp_couple ; *couples = tmp_couple ;
} }
else
{ // Sinon on cherche si le couple existe déjà dans la liste else // If the couple list exists already
if (timeval_to_ms(message.request_time) != 0) // Paquet explicite { // we search the list for the couple
if (timeval_to_ms(message.request_time) != 0) // Explicit packet
{ {
while (tmp_couple != NULL) while (tmp_couple != NULL)
{ // Critère : MAC et heure d'émission identiques. { // Research criterion: MAC and transmission time
if(mac_cmp(message.mobile_mac_addr_bytes, tmp_couple->mobile_mac_addr_bytes) == 1 if(mac_cmp(message.mobile_mac_addr_bytes,
&& sub_date(message.request_time, tmp_couple->request_time) == 0) tmp_couple->mobile_mac_addr_bytes) == 1
break ; // Si le couple existe déjà, on s'arrête dessus. && sub_date(message.request_time,
tmp_couple->request_time) == 0)
break ; // If the couple exists, we stop on it
tmp_couple = tmp_couple->next ; tmp_couple = tmp_couple->next ;
} }
} }
else // Paquet implicite else // Implicit packet
{ {
while (tmp_couple != NULL) while (tmp_couple != NULL)
{ // Critère : MAC identiques et décalage des heures de réception par les AP d'au maximum 10 ms. { // Research criterion: MAC addresses equals and reception
if(mac_cmp(message.mobile_mac_addr_bytes, tmp_couple->mobile_mac_addr_bytes) == 1 // times on the APs less than 10 ms
&& sub_date(message.start_time, tmp_couple->request_time) <= 10) // TODO : définir un paramètre pour le décalage maximal // TODO : define an option for the maximal difference time.
break ; // Si le couple existe déjà, on s'arrête dessus. if(mac_cmp(message.mobile_mac_addr_bytes,
tmp_couple->mobile_mac_addr_bytes) == 1
&& sub_date(message.start_time,
tmp_couple->request_time) <= 10)
break ; // If the couple exists, we stop on it
tmp_couple = tmp_couple->next ; tmp_couple = tmp_couple->next ;
} }
} }
if (tmp_couple == NULL) // Si couple inexistant dans la liste if (tmp_couple == NULL) // If the couple does not exist in the list,
{ {
printf("Création du couple.\n") ; printf("Create new couple.\n") ;
tmp_couple = malloc(sizeof(couple_list)) ; // on crée un nouveau couple. tmp_couple = malloc(sizeof(couple_list)) ; // create it.
memcpy(tmp_couple->mobile_mac_addr_bytes, message.mobile_mac_addr_bytes, 6) ; memcpy(tmp_couple->mobile_mac_addr_bytes,
if (timeval_to_ms(message.request_time) != 0) // Paquet explicite message.mobile_mac_addr_bytes, 6) ;
tmp_couple->request_time = message.request_time ; // Heure d'émission par le mobile if (timeval_to_ms(message.request_time) != 0) // Explicit packet
else // Paquet implicite // Transmission time on the mobile:
tmp_couple->request_time = message.start_time ; // Heure de réception par l'AP tmp_couple->request_time = message.request_time ;
tmp_couple->start_time = start_time ; // Enregistrement de la date locale de l'agrégateur et non de la date de réception de la demande sur l'AP else // Implicit packet
// Reception time on the AP:
tmp_couple->request_time = message.start_time ;
// Save locale time on the aggregator (not the reception time
// on the AP):
tmp_couple->start_time = start_time ;
tmp_couple->x_position = message.x_position ; tmp_couple->x_position = message.x_position ;
tmp_couple->y_position = message.y_position ; tmp_couple->y_position = message.y_position ;
tmp_couple->z_position = message.z_position ; tmp_couple->z_position = message.z_position ;
@ -481,17 +544,17 @@ void got_couple_info(couple_list **couples, couple_message message)
tmp_couple->info = tmp_info ; tmp_couple->info = tmp_info ;
*couples = tmp_couple ; *couples = tmp_couple ;
} }
else // Si couple trouvé dans la liste else // If the couple was found in the list
{ {
if (tmp_couple->info == NULL) // Si on a déjà envoyé les infos de ce couple au serveur if (tmp_couple->info == NULL)
{ { // We already sent to the server data for this couple
printf("Demande déjà traitée.\n") ; printf("Request already treated.\n") ;
free(tmp_info) ; free(tmp_info) ;
} }
else else
{ {
printf("Ajout des informations au couple.\n") ; printf("Add information to the couple.\n") ;
tmp_info->next = tmp_couple->info ; // on ajoute l'info. tmp_info->next = tmp_couple->info ; // Add data
tmp_couple->info = tmp_info ; tmp_couple->info = tmp_info ;
} }
} }
@ -500,7 +563,7 @@ void got_couple_info(couple_list **couples, couple_message message)
/* Vide la liste chaînée de couples */ /* Empty the couple list */
void free_couple_list(couple_list **couples) void free_couple_list(couple_list **couples)
{ {
couple_list *couple_ptr = *couples ; couple_list *couple_ptr = *couples ;
@ -527,35 +590,37 @@ void free_couple_list(couple_list **couples)
#ifdef DEBUG #ifdef DEBUG
/* Affiche la liste des couples */ /* Prints the couple list */
void print_couple_list(couple_list *couples) void print_couple_list(couple_list *couples)
{ {
couple_list *couple_ptr = couples ; couple_list *couple_ptr = couples ;
couple_info_list *info_ptr = NULL ; couple_info_list *info_ptr = NULL ;
char *mobile_mac_string ; char *mobile_mac_string ;
if (couples == NULL) // Si la liste est vide if (couples == NULL) // Empty list
{ {
printf("Aucun couple.\n") ; // on l'affiche. printf("Aucun couple.\n") ;
return ; return ;
} }
while (couple_ptr != NULL) while (couple_ptr != NULL)
{ {
info_ptr = couple_ptr->info ; // On récupère le pointeur de la sous-liste info_ptr = couple_ptr->info ; // Get the sub-list pointer
mobile_mac_string = mac_bytes_to_string(couple_ptr->mobile_mac_addr_bytes) ; mobile_mac_string =
printf("MAC du mobile : %s\n\ mac_bytes_to_string(couple_ptr->mobile_mac_addr_bytes) ;
Numéro de séquence : %llu\n\ printf("Mobile MAC: %s\n"
Heure de réception de la demande de localisation : %llu\n\ "Sequence number: %llu\n"
\n", "Reception timestamp: %llu\n"
"\n",
mobile_mac_string, mobile_mac_string,
timeval_to_ms(couple_ptr->request_time), timeval_to_ms(couple_ptr->request_time),
timeval_to_ms(couple_ptr->start_time) timeval_to_ms(couple_ptr->start_time)
) ; ) ;
free(mobile_mac_string) ; free(mobile_mac_string) ;
while (info_ptr != NULL) // On parcourt toutes les informations relative au couple courant // Parse information relative to the current couple
while (info_ptr != NULL)
{ {
print_couple_info(info_ptr) ; print_couple_info(info_ptr) ;
putchar('\n') ; putchar('\n') ;
@ -570,7 +635,7 @@ Heure de réception de la demande de localisation : %llu\n\
/* Affiche un maillon d'une couple_info_list */ /* Prints an element of a couple_info_list */
void print_couple_info(couple_info_list *info) void print_couple_info(couple_info_list *info)
{ {
char *ap_mac_string ; char *ap_mac_string ;
@ -578,8 +643,8 @@ void print_couple_info(couple_info_list *info)
return ; return ;
ap_mac_string = mac_bytes_to_string(info->ap_mac_addr_bytes) ; ap_mac_string = mac_bytes_to_string(info->ap_mac_addr_bytes) ;
printf("\tMAC de l'AP : %s\n\ printf("\tAP MAC: %s\n"
\tPuissance du signal : %d dBm\n", "\tSignal strength: %d dBm\n",
ap_mac_string, ap_mac_string,
info->antenna_signal_dbm - 0x100 info->antenna_signal_dbm - 0x100
) ; ) ;
@ -613,22 +678,34 @@ char* ip_bytes_to_string(unsigned char *ip_binary)
/* Affiche le mode d'emploi du programme */
void print_usage() void print_usage()
{ {
printf("Usage :\n\ printf("Usage:\n"
\t%s [-f config_file] [-l listening_port] [-i positionner_ip] [-p positioner_port] [-a aggregate_timeout] [-k keep_timeout] [-c check_interval] [-o output_file]\n\ "\t%s [-f config_file] [-l listening_port] [-i positionner_ip]"
Options générales :\n\ " [-p positioner_port] [-a aggregate_timeout] [-k keep_timeout]"
\t-f config_file : spécifie un fichier de configuration à lire à la place du fichier par défaut.\n\ " [-c check_interval] [-o output_file]\n"
Options serveur :\n\
\t-l listening_port : seules les demandes envoyées sur ce port seront retenues (défaut : %d).\n\ "Main options:\n"
\t-i positionner_ip : adresse IP du serveur de calcul auquel seront transmises les demandes (défaut : %s).\n\ "\t-f config_file\tUse 'config_file' instead of the default"
\t-p positioner_port : les demandes agrégées seront transmises sur ce port du serveur de calcul (défaut : %d).\n\ " configuration file.\n"
Options d'agrégation :\n\
\t-a aggregate_timeout : temps d'agrégation (défaut : %d millisecondes)\n\ "Server options:\n"
\t-k keep_timeout : temps de garde des demandes (défaut : %d millisecondes)\n\ "\t-l listening_port\tOnly requests sent on this port will be"
\t-c check_interval : délai entre deux vérifications des demandes en mémoire, et agrégation (défaut : %d micro-secondes)\n\ " treated (default: %d).\n"
", "\t-i positionner_ip\tIP address of the localisation server"
" (default: %s).\n"
"\t-p positioner_port\tAggregated requests are transmitted to"
" the localisation server on this port (default: %d).\n"
"Aggregation options:\n"
"\t-a aggregate_timeout\tRequests are stored during"
" 'aggregate_timeout' before to be grouped (default:"
" %d millisecondes).\n"
"\t-k keep_timeout\t\tAggregated requests are kept during"
" 'keep_timeout' milliseconds (default: %d milliseconds).\n"
"\t-c check_interval\tTime between two checks of the stored"
" requests (default\t%d microseconds).\n"
,
program_name, program_name,
AGGREGATE_DEFAULT_PORT, AGGREGATE_DEFAULT_PORT,
POSITIONER_DEFAULT_IP, POSITIONER_DEFAULT_IP,