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

[i-c] Mode passif dans aggregator et listener 

Implantation (basique) du mode passif dans aggregator et listener.

git-svn-id: https://pif.pu-pm.univ-fcomte.fr/svn/loc@107 785a6c6c-259e-4ff1-8b91-dc31627914f0
This commit is contained in:
Matteo Cypriani 2009-09-03 09:09:48 +00:00
parent 24fef29457
commit 629ed77470
4 changed files with 176 additions and 134 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -9,6 +9,7 @@
#include "../../libowlps/owlps.h" #include "../../libowlps/owlps.h"
#include <confuse.h> #include <confuse.h>
#define DEBUG
//#define TIMESTAMP // Décommenter pour afficher le timestamp à chaque ligne du fichier de sortie. //#define TIMESTAMP // Décommenter pour afficher le timestamp à chaque ligne du fichier de sortie.
@ -64,8 +65,10 @@ typedef struct _couple_list
/* En-têtes de fonctions */ /* En-têtes de fonctions */
void got_couple_info(couple_list **couples, couple_message message) ; void got_couple_info(couple_list **couples, couple_message message) ;
void free_couple_list(couple_list **couples) ; void free_couple_list(couple_list **couples) ;
#ifdef DEBUG
void print_couple_list(couple_list *couples) ; void print_couple_list(couple_list *couples) ;
void print_couple_info(couple_info_list *info) ; void print_couple_info(couple_info_list *info) ;
#endif // DEBUG
void* monitor_couple_list(couple_list **couples) ; void* monitor_couple_list(couple_list **couples) ;
int Db_write_request(couple_message message, BOOL ref) ; int Db_write_request(couple_message message, BOOL ref) ;
int DbAccessPoint(couple_message message, PGconn *conn); int DbAccessPoint(couple_message message, PGconn *conn);

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

@ -5,7 +5,6 @@
#include "owlps-aggregator.h" #include "owlps-aggregator.h"
#define DEBUG
cfg_t *cfg ; // Structure contenant la configuration cfg_t *cfg ; // Structure contenant la configuration
@ -415,7 +414,10 @@ void got_couple_info(couple_list **couples, couple_message message)
printf("Création de la liste des couples.\n") ; printf("Création de la liste des couples.\n") ;
tmp_couple = malloc(sizeof(couple_list)) ; // on la crée. tmp_couple = malloc(sizeof(couple_list)) ; // on la crée.
memcpy(tmp_couple->mobile_mac_addr_bytes, message.mobile_mac_addr_bytes, 6) ; memcpy(tmp_couple->mobile_mac_addr_bytes, message.mobile_mac_addr_bytes, 6) ;
tmp_couple->request_time = message.request_time ; if (timeval_to_ms(message.request_time) != 0) // Paquet explicite
tmp_couple->request_time = message.request_time ; // Heure d'émission par le mobile
else // Paquet implicite
tmp_couple->request_time = message.start_time ; // Heure de réception par l'AP
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 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
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 ;
@ -426,21 +428,37 @@ void got_couple_info(couple_list **couples, couple_message message)
*couples = tmp_couple ; *couples = tmp_couple ;
} }
else else
{ { // Sinon on cherche si le couple existe déjà dans la liste
while (tmp_couple != NULL) // Sinon on cherche si le couple existe déjà dans la liste if (timeval_to_ms(message.request_time) != 0) // Paquet explicite
{ {
if(mac_cmp(message.mobile_mac_addr_bytes, tmp_couple->mobile_mac_addr_bytes) == 1 while (tmp_couple != NULL)
&& message.request_time.tv_usec == tmp_couple->request_time.tv_usec) // Si le couple existe déjà, { // Critère : MAC et heure d'émission identiques.
break ; // on s'arrête dessus. if(mac_cmp(message.mobile_mac_addr_bytes, tmp_couple->mobile_mac_addr_bytes) == 1
tmp_couple = tmp_couple->next ; && sub_date(message.request_time, tmp_couple->request_time) == 0)
} break ; // Si le couple existe déjà, on s'arrête dessus.
tmp_couple = tmp_couple->next ;
}
}
else // Paquet implicite
{
while (tmp_couple != NULL)
{ // Critère : MAC identiques et décalage des heures de réception par les AP d'au maximum 10 ms.
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) // TODO : définir un paramètre pour le décalage maximal
break ; // Si le couple existe déjà, on s'arrête dessus.
tmp_couple = tmp_couple->next ;
}
}
if (tmp_couple == NULL) // Si couple inexistant dans la liste if (tmp_couple == NULL) // Si couple inexistant dans la liste
{ {
printf("Création du couple.\n") ; printf("Création du couple.\n") ;
tmp_couple = malloc(sizeof(couple_list)) ; // on crée un nouveau couple. tmp_couple = malloc(sizeof(couple_list)) ; // on crée un nouveau couple.
memcpy(tmp_couple->mobile_mac_addr_bytes, message.mobile_mac_addr_bytes, 6) ; memcpy(tmp_couple->mobile_mac_addr_bytes, message.mobile_mac_addr_bytes, 6) ;
tmp_couple->request_time = message.request_time ; if (timeval_to_ms(message.request_time) != 0) // Paquet explicite
tmp_couple->request_time = message.request_time ; // Heure d'émission par le mobile
else // Paquet implicite
tmp_couple->request_time = message.start_time ; // Heure de réception par l'AP
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 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
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 ;
@ -495,6 +513,7 @@ void free_couple_list(couple_list **couples)
#ifdef DEBUG
/* Affiche la liste des couples */ /* Affiche la liste des couples */
void print_couple_list(couple_list *couples) void print_couple_list(couple_list *couples)
{ {
@ -553,6 +572,7 @@ void print_couple_info(couple_info_list *info)
) ; ) ;
free(ap_mac_string) ; free(ap_mac_string) ;
} }
#endif // DEBUG

5
infrastructure-centred/owlps-listener/owlps-listener.h
View File

@ -10,6 +10,8 @@
#define USE_PTHREAD // POSIX threads available? #define USE_PTHREAD // POSIX threads available?
//#define PLATFORM_ATHEROS // Will we compile to an Atheros platform? //#define PLATFORM_ATHEROS // Will we compile to an Atheros platform?
#define DEBUG
#include "../../libowlps/owlps.h" #include "../../libowlps/owlps.h"
#include <pcap.h> #include <pcap.h>
@ -36,10 +38,11 @@
/* Arguments & configuration du programme */ /* Arguments & configuration du programme */
#define OPTIONS "m:d:f:kl:p:r:w:v" // Chaîne pour getopt #define OPTIONS "d:f:kl:m:p:qr:vw:" // Chaîne pour getopt
#define DEFAULT_CONFIG_FILE "/usr/local/etc/owlps/owlps-listener.conf" #define DEFAULT_CONFIG_FILE "/usr/local/etc/owlps/owlps-listener.conf"
enum {MODE_ACTIVE = 'a', MODE_PASSIVE = 'p', MODE_MIXED = 'm'} ; enum {MODE_ACTIVE = 'a', MODE_PASSIVE = 'p', MODE_MIXED = 'm'} ;
/* En-têtes des fonctions */ /* En-têtes des fonctions */
#ifdef USE_PTHREAD #ifdef USE_PTHREAD
void* keep_mode_monitor(char *iface) ; void* keep_mode_monitor(char *iface) ;

260
infrastructure-centred/owlps-listener/owlps-listenerd.c
View File

@ -5,7 +5,7 @@
#include "owlps-listener.h" #include "owlps-listener.h"
#define DEBUG
unsigned char mac[6] ; // Adresse MAC de l'AP unsigned char mac[6] ; // Adresse MAC de l'AP
@ -318,6 +318,7 @@ void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *p
unsigned short dst_port ; // Port destination du paquet capturé unsigned short dst_port ; // Port destination du paquet capturé
int i ; // Compteur int i ; // Compteur
/* Traitements communs */
memcpy(&rtap_bytes, &data[2], sizeof(unsigned short)) ; // Recopie les deux octets à partir du troisième octet de donnée qui est la taille de l'en-tête rtap (change avec des flags) memcpy(&rtap_bytes, &data[2], sizeof(unsigned short)) ; // Recopie les deux octets à partir du troisième octet de donnée qui est la taille de l'en-tête rtap (change avec des flags)
#ifdef PLATFORM_ATHEROS #ifdef PLATFORM_ATHEROS
rtap_bytes = ((rtap_bytes & 0xff00) >> 8) + ((rtap_bytes & 0xff) << 8) ; rtap_bytes = ((rtap_bytes & 0xff00) >> 8) + ((rtap_bytes & 0xff) << 8) ;
@ -345,28 +346,30 @@ void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *p
} }
#endif // DEBUG #endif // DEBUG
memcpy(couple.ap_mac_addr_bytes, mac, 6); // On copie la MAC de l'AP
memcpy(couple.mobile_mac_addr_bytes, &data[rtap_bytes+10], 6); // L'adresse MAC source est 10 octets plus loin que le type de paquet 802.11
couple.start_time = header->ts ; // L'heure de capture du paquet est contenue dans l'en-tête pcap
couple.request_time.tv_sec = 0 ; // L'heure d'envoi par le mobile est inconnue (à moins qu'il ne s'agisse d'un paquet explicite)
couple.request_time.tv_usec = 0 ;
// TODO : if (est un paquet IP)
memcpy(couple.mobile_ip_addr_bytes, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + 12], 4); // L'adresse IP source est à la position 12 de l'en-tête IP
// TODO : else mettre l'IP à zéro
/* Mode actif */ /* Mode actif */
if ((GET_MODE() == MODE_ACTIVE || GET_MODE() == MODE_MIXED) if ((GET_MODE() == MODE_ACTIVE || GET_MODE() == MODE_MIXED)
&& raw_packet_type == RAW_PACKET_TYPE_DATA // Si le paquet est de type data, && raw_packet_type == RAW_PACKET_TYPE_DATA // Si le paquet est de type data,
&& data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + 9] == RAW_PACKET_PROTO_UDP // et de protocole UDP (9 : position du champ "Protocol" de l'en-tête IP), && data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + 9] == RAW_PACKET_PROTO_UDP // et de protocole UDP (9 : position du champ "Protocol" de l'en-tête IP),
&& dst_port == LOC_REQUEST_DEFAULT_PORT // et le port de destination est le bon, && dst_port == GET_LISTENING_PORT() // et le port de destination est le bon,
&& ! IS_RETRY(raw_packet_flags)) // et ce n'est pas un Retry. && ! IS_RETRY(raw_packet_flags)) // et ce n'est pas un Retry.
{ {
memcpy(couple.ap_mac_addr_bytes, mac, 6); // On copie la MAC de l'AP BOOL err = FALSE ;
memcpy(couple.mobile_mac_addr_bytes, &data[rtap_bytes+10], 6); // L'adresse MAC source est 10 octets plus loin que le type de paquet
memcpy(couple.mobile_ip_addr_bytes, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + 12], 4); // L'adresse IP source est à la position 12 de l'en-tête IP
gettimeofday(&couple.start_time, NULL) ;
packet_type = data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE] ; packet_type = data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE] ;
memcpy(&couple.request_time, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 1], sizeof(struct timeval));
switch(packet_type) switch(packet_type)
{ {
case PACKET_TYPE_NORMAL : case PACKET_TYPE_NORMAL :
if (GET_VERBOSE()) if (GET_VERBOSE())
printf("\nPaquet normal reçu.\n") ; printf("\nPaquet explicite normal reçu.\n") ;
couple.direction = 0 ; couple.direction = 0 ;
couple.x_position = 0 ; couple.x_position = 0 ;
couple.y_position = 0 ; couple.y_position = 0 ;
@ -375,7 +378,7 @@ void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *p
case PACKET_TYPE_CALIBRATION : case PACKET_TYPE_CALIBRATION :
if (GET_VERBOSE()) if (GET_VERBOSE())
printf("\nPaquet de calibration reçu.\n") ; printf("\nPaquet explicite de calibration reçu.\n") ;
couple.direction = data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 9]; couple.direction = data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 9];
memcpy(&couple.x_position, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 10], sizeof(float)); memcpy(&couple.x_position, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 10], sizeof(float));
memcpy(&couple.y_position, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 14], sizeof(float)); memcpy(&couple.y_position, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 14], sizeof(float));
@ -384,100 +387,120 @@ void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *p
default : default :
if (GET_VERBOSE()) if (GET_VERBOSE())
printf("\nPaquet bizarre reçu.\n") ; printf("\nPaquet explicite bizarre reçu.\n") ;
fprintf(stderr, "Erreur ! Type de paquet inconnu (%d).\n", packet_type) ; fprintf(stderr, "Erreur ! Type de paquet explicite inconnu (%d).\n", packet_type) ;
return ; err = TRUE ;
} }
if (err)
{
if (GET_MODE() == MODE_ACTIVE)
return ;
else if (GET_VERBOSE())
printf("\nCe paquet explicite bizarre sera traité comme implicite.\n") ;
}
else
memcpy(&couple.request_time, &data[rtap_bytes + IEEE80211_HEADER_SIZE + LLC_HEADER_SIZE + IP_HEADER_SIZE + UDP_HEADER_SIZE + 1], sizeof(struct timeval));
}
memcpy(&rtap_presentflags, &data[RTAP_P_PRESENTFLAGS], RTAP_L_PRESENTFLAGS); // Récupère les flags de l'en-tête rtap else if (GET_MODE() == MODE_PASSIVE || GET_MODE() == MODE_MIXED)
{
if (GET_VERBOSE())
printf("\nPaquet implicite reçu.\n") ;
}
else // Mode actif uniquement, le paquet n'étant pas une demande explicite
return ;
/* Traitement de l'en-tête Radiotap */
memcpy(&rtap_presentflags, &data[RTAP_P_PRESENTFLAGS], RTAP_L_PRESENTFLAGS); // Récupère les flags de l'en-tête rtap
#ifdef PLATFORM_ATHEROS #ifdef PLATFORM_ATHEROS
rtap_presentflags = ((rtap_presentflags & 0xff000000) >> 24) + ((rtap_presentflags & 0xff0000) >> 8) + ((rtap_presentflags & 0xff00) << 8) + ((rtap_presentflags & 0xff) << 24) ; rtap_presentflags = ((rtap_presentflags & 0xff000000) >> 24) + ((rtap_presentflags & 0xff0000) >> 8) + ((rtap_presentflags & 0xff00) << 8) + ((rtap_presentflags & 0xff) << 24) ;
#endif // PLATFORM_ATHEROS #endif // PLATFORM_ATHEROS
for (i = 0 ; i < 15 ; i++) // Initialisation de la structure des champs présents for (i = 0 ; i < 15 ; i++) // Initialisation de la structure des champs présents
check[i] = FALSE ; check[i] = FALSE ;
rtap_position = 8 ; // Début des champs déterminés par le present flag rtap_position = 8 ; // Début des champs déterminés par le present flag
for(i=0 ; i < 15 ; i++) // on teste les 15 premiers bits du champ flag afin de valider la présence et de les copier for(i=0 ; i < 15 ; i++) // on teste les 15 premiers bits du champ flag afin de valider la présence et de les copier
{ {
if ((rtap_presentflags % 2) == 1) if ((rtap_presentflags % 2) == 1)
{ {
switch(i) switch(i)
{ {
case RTAP_MACTS: case RTAP_MACTS:
check[RTAP_MACTS] = TRUE ; check[RTAP_MACTS] = TRUE ;
rtap_position += RTAP_L_MACTS ; rtap_position += RTAP_L_MACTS ;
break ; break ;
case RTAP_FLAGS: case RTAP_FLAGS:
check[RTAP_FLAGS] = TRUE; check[RTAP_FLAGS] = TRUE;
rtap_position += RTAP_L_FLAGS ; rtap_position += RTAP_L_FLAGS ;
break ; break ;
case RTAP_RATE: case RTAP_RATE:
check[RTAP_RATE] = TRUE; check[RTAP_RATE] = TRUE;
rtap_position += RTAP_L_RATE ; rtap_position += RTAP_L_RATE ;
break ; break ;
case RTAP_CHANNEL: case RTAP_CHANNEL:
rtap_position += RTAP_L_CHANNEL ; rtap_position += RTAP_L_CHANNEL ;
rtap_position += RTAP_L_CHANNELTYPE ; rtap_position += RTAP_L_CHANNELTYPE ;
break ; break ;
case RTAP_FHSS: case RTAP_FHSS:
check[RTAP_FHSS] = TRUE; check[RTAP_FHSS] = TRUE;
rtap_position += RTAP_L_FHSS ; rtap_position += RTAP_L_FHSS ;
break ; break ;
case RTAP_ANTENNASIGNALDBM: case RTAP_ANTENNASIGNALDBM:
memcpy(&(couple.antenna_signal_dbm), &data[rtap_position], RTAP_L_ANTENNASIGNALDBM) ; memcpy(&(couple.antenna_signal_dbm), &data[rtap_position], RTAP_L_ANTENNASIGNALDBM) ;
check[RTAP_ANTENNASIGNALDBM] = TRUE; check[RTAP_ANTENNASIGNALDBM] = TRUE;
if (GET_VERBOSE()) if (GET_VERBOSE())
printf("Antenna Signal : %d dBm\n", couple.antenna_signal_dbm - 0x100); printf("Antenna Signal : %d dBm\n", couple.antenna_signal_dbm - 0x100);
rtap_position += RTAP_L_ANTENNASIGNALDBM ; rtap_position += RTAP_L_ANTENNASIGNALDBM ;
break ; break ;
case RTAP_ANTENNANOISEDBM: case RTAP_ANTENNANOISEDBM:
check[RTAP_ANTENNANOISEDBM] = TRUE; check[RTAP_ANTENNANOISEDBM] = TRUE;
rtap_position += RTAP_L_ANTENNANOISEDBM ; rtap_position += RTAP_L_ANTENNANOISEDBM ;
break ; break ;
case RTAP_LOCKQUALITY: case RTAP_LOCKQUALITY:
check[RTAP_LOCKQUALITY] = TRUE; check[RTAP_LOCKQUALITY] = TRUE;
rtap_position += RTAP_L_LOCKQUALITY ; rtap_position += RTAP_L_LOCKQUALITY ;
break ; break ;
case RTAP_TXATTENUATION: case RTAP_TXATTENUATION:
check[RTAP_TXATTENUATION] = TRUE; check[RTAP_TXATTENUATION] = TRUE;
rtap_position += RTAP_L_TXATTENUATION ; rtap_position += RTAP_L_TXATTENUATION ;
break ; break ;
case RTAP_TXATTENUATIONDB: case RTAP_TXATTENUATIONDB:
check[RTAP_TXATTENUATIONDB] = TRUE; check[RTAP_TXATTENUATIONDB] = TRUE;
rtap_position += RTAP_L_TXATTENUATIONDB ; rtap_position += RTAP_L_TXATTENUATIONDB ;
break ; break ;
case RTAP_TXATTENUATIONDBM: case RTAP_TXATTENUATIONDBM:
check[RTAP_TXATTENUATIONDBM] = TRUE; check[RTAP_TXATTENUATIONDBM] = TRUE;
rtap_position += RTAP_L_TXATTENUATIONDBM ; rtap_position += RTAP_L_TXATTENUATIONDBM ;
break ; break ;
case RTAP_ANTENNA: case RTAP_ANTENNA:
check[RTAP_ANTENNA] = TRUE; check[RTAP_ANTENNA] = TRUE;
rtap_position += RTAP_L_ANTENNA ; rtap_position += RTAP_L_ANTENNA ;
break ; break ;
case RTAP_ANTENNASIGNALDB: case RTAP_ANTENNASIGNALDB:
check[RTAP_ANTENNASIGNALDB] = TRUE; check[RTAP_ANTENNASIGNALDB] = TRUE;
rtap_position += RTAP_L_ANTENNASIGNALDB ; rtap_position += RTAP_L_ANTENNASIGNALDB ;
break ; break ;
case RTAP_ANTENNANOISEDB: case RTAP_ANTENNANOISEDB:
check[RTAP_ANTENNANOISEDB] = TRUE; check[RTAP_ANTENNANOISEDB] = TRUE;
rtap_position += RTAP_L_ANTENNANOISEDB ; rtap_position += RTAP_L_ANTENNANOISEDB ;
break ; break ;
case RTAP_FCS: case RTAP_FCS:
check[RTAP_FCS] = TRUE; check[RTAP_FCS] = TRUE;
rtap_position += RTAP_L_FCS ; rtap_position += RTAP_L_FCS ;
break ; break ;
} }
} }
rtap_presentflags /= 2 ; rtap_presentflags /= 2 ;
} }
if (GET_VERBOSE()) if (GET_VERBOSE())
{ {
char *ap_mac_string = mac_bytes_to_string(couple.ap_mac_addr_bytes) ; char *ap_mac_string = mac_bytes_to_string(couple.ap_mac_addr_bytes) ;
char *mobile_mac_string = mac_bytes_to_string(couple.mobile_mac_addr_bytes) ; char *mobile_mac_string = mac_bytes_to_string(couple.mobile_mac_addr_bytes) ;
printf("\ printf("\
*** Couple à envoyer ***\n\ *** Couple à envoyer ***\n\
\tMAC AP : %s\n\ \tMAC AP : %s\n\
\tMAC mobile : %s\n\ \tMAC mobile : %s\n\
@ -489,33 +512,26 @@ void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *p
\tPosition Z : %f\n\ \tPosition Z : %f\n\
\tDirection : %hhd\n\ \tDirection : %hhd\n\
", ",
ap_mac_string, ap_mac_string,
mobile_mac_string, mobile_mac_string,
timeval_to_ms(couple.request_time), timeval_to_ms(couple.request_time),
timeval_to_ms(couple.start_time), timeval_to_ms(couple.start_time),
couple.antenna_signal_dbm - 0x100, couple.antenna_signal_dbm - 0x100,
couple.x_position, couple.x_position,
couple.y_position, couple.y_position,
couple.z_position, couple.z_position,
couple.direction couple.direction
) ; ) ;
free(ap_mac_string) ; free(ap_mac_string) ;
free(mobile_mac_string) ; free(mobile_mac_string) ;
}
/* Envoi du couple au serveur d'aggrégation */
nsent = sendto(sockfd, (void *) &couple, sizeof(couple), 0, (struct sockaddr *) server, (socklen_t) sizeof(*server)) ;
if (nsent != (ssize_t) sizeof(couple))
{
perror("Erreur lors de l'envoi du couple au serveur ") ;
return ;
}
} }
/* Mode passif */ /* Envoi du couple au serveur d'aggrégation */
else if (GET_MODE() == MODE_PASSIVE || GET_MODE() == MODE_MIXED) nsent = sendto(sockfd, (void *) &couple, sizeof(couple), 0, (struct sockaddr *) server, (socklen_t) sizeof(*server)) ;
if (nsent != (ssize_t) sizeof(couple))
{ {
/* TODO */ perror("Erreur lors de l'envoi du couple au serveur ") ;
return ;
} }
} }