2008-02-14 09:45:47 +01:00
/*
* This is the rtapanalyser library , Wi - Fi packet sniffer and analyser ,
* thanks to the radiotap header of each packet .
*/
2008-02-22 16:04:49 +01:00
# include "rtapscanmob.h"
2008-02-14 09:45:47 +01:00
2008-02-22 16:04:49 +01:00
BOOL run = TRUE ;
2008-02-14 09:45:47 +01:00
2008-02-22 16:04:49 +01:00
/* Capture des paquets en utilisant l'interface "capture_iface" pendant "capture_time" millisecondes,
* et enregistre les paquets lus dans " results " */
int capture ( char * capture_iface , unsigned long capture_time , mac_list * * results , BOOL print_values )
2008-02-14 09:45:47 +01:00
{
2008-02-22 16:04:49 +01:00
pcap_t * handle ; // Descripteur de capture de paquets
char errbuf [ PCAP_ERRBUF_SIZE ] ; // Message d'erreur
struct timeval tbegin , tcurrent ;
/* Sous-fonction de traitement des paquets capturés */
void got_packet ( u_char * args , const struct pcap_pkthdr * header , const u_char * packet )
{
read_packet ( args , header , packet , results , print_values ) ; // On appelle la fonction read_packet() avec les mêmes arguments, plus "results" que l'on passe en modification, et "print_values" qui indique si on doit afficher le paquet.
}
2008-02-14 09:45:47 +01:00
2008-02-22 16:04:49 +01:00
handle = pcap_open_live ( capture_iface , BUFSIZ , 1 , 1000 , errbuf ) ; // Début de la capture
if ( handle = = NULL ) // Le lancement de la capture a-t-il échoué ?
2008-02-14 09:45:47 +01:00
{
2008-02-22 16:04:49 +01:00
fprintf ( stderr , " Impossible d'ouvrir l'interface « %s » : %s \n " , capture_iface , errbuf ) ;
return ERR_OPENING_IFACE ;
2008-02-14 09:45:47 +01:00
}
2008-02-22 16:04:49 +01:00
if ( capture_time > 0 ) // Si le temps de capture est positif
{
gettimeofday ( & tbegin , NULL ) ; // Récupère l'heure courante (heure du lancement de la capture)
2008-02-14 09:45:47 +01:00
2008-02-22 16:04:49 +01:00
while ( run )
{
pcap_loop ( handle , 1 , got_packet , NULL ) ; // Collecte 1 paquet et appelle la fonction got_packet quand pcaploop a recupéré des paquets
2008-02-14 09:45:47 +01:00
2008-02-22 16:04:49 +01:00
gettimeofday ( & tcurrent , NULL ) ; // Récupère l'heure courante
if ( sub_date ( tcurrent , tbegin ) > capture_time ) // Si le temps de capture est écoulé
break ; // on arrête la collecte.
}
2008-02-14 09:45:47 +01:00
}
2008-02-22 16:04:49 +01:00
else // On fonctionne en mode démon (tant que run est vrai)
while ( run )
pcap_loop ( handle , 1 , got_packet , NULL ) ; // Collecte 1 paquet et appelle la fonction got_packet quand pcaploop a recupéré des paquets
pcap_close ( handle ) ; // Arrêt de la capture.
return 0 ;
2008-02-14 09:45:47 +01:00
}
2008-02-22 16:04:49 +01:00
/* Traite un paquet et enregistre les valeurs dans la liste des résultats (results) */
void read_packet ( u_char * args , const struct pcap_pkthdr * header , const u_char * packet , mac_list * * results , BOOL print_values )
2008-02-14 09:45:47 +01:00
{
2008-02-22 16:04:49 +01:00
unsigned char * data = ( unsigned char * ) packet ; // Recopie dans data l'adresse du paquet capturé
unsigned short rtap_bytes ; // Taille des données reçues
unsigned int rtap_presentflags , rtap_position ;
BOOL check [ 15 ] ; // Champs présents
unsigned char raw_packet_type ; // Type du packet reçu (beacon, data...)
unsigned char mac_addr_bytes [ 6 ] ;
mac_list * tmp_mac = NULL ;
ss_list * tmp_ss = NULL ;
int i ; // Compteur
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)
raw_packet_type = data [ rtap_bytes ] ; // Au bout de l'en-tête rtap il y a celle du 802.11 dont le premier determine le type (beacon ou pas)
if ( raw_packet_type = = RAW_PACKET_TYPE_BEACON ) // Si le paquet est de type beacon, on le traite
{
memcpy ( mac_addr_bytes , & data [ rtap_bytes + 10 ] , 6 ) ; // Dans le cas du beacon, l'adresse MAC est 10 octets plus loin que le type de paquet
memcpy ( & rtap_presentflags , & data [ RTAP_P_PRESENTFLAGS ] , RTAP_L_PRESENTFLAGS ) ; // Récupère les flags de l'en-tête rtap
/* Ajout du résultat du scan à la structure */
tmp_ss = malloc ( sizeof ( ss_list ) ) ;
tmp_ss - > next = NULL ;
memcpy ( & ( tmp_ss - > header_revision ) , & data [ RTAP_P_HREVISION ] , RTAP_L_HREVISION ) ;
memcpy ( & ( tmp_ss - > header_pad ) , & data [ RTAP_P_HPAD ] , RTAP_L_HPAD ) ;
memcpy ( & ( tmp_ss - > header_length ) , & data [ RTAP_P_HLENGTH ] , RTAP_L_HLENGTH ) ;
memcpy ( & ( tmp_ss - > present_flags ) , & data [ RTAP_P_PRESENTFLAGS ] , RTAP_L_PRESENTFLAGS ) ;
for ( i = 0 ; i < 15 ; i + + ) // Initialisation de la structure des champs présents
tmp_ss - > check [ i ] = FALSE ;
rtap_position = 8 ; // début des champs déterminés par le present flag
if ( print_values )
{
char * mac_string = mac_bytes_to_string ( mac_addr_bytes ) ;
printf ( " [%s] \n " , mac_string ) ;
printf ( " Header revision : %hhu \n " , tmp_ss - > header_revision ) ;
printf ( " Header Pad : %hhu \n " , tmp_ss - > header_pad ) ;
printf ( " Header Length : %hu \n " , tmp_ss - > header_length ) ;
printf ( " Present flags : %#010lx \n " , tmp_ss - > present_flags ) ;
free ( mac_string ) ;
}
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 )
{
switch ( i )
{
case RTAP_MACTS :
memcpy ( & ( tmp_ss - > mac_timestamp ) , & data [ rtap_position ] , RTAP_L_MACTS ) ;
tmp_ss - > check [ RTAP_MACTS ] = TRUE ;
if ( print_values )
printf ( " Mac timestamp : %llu \n " , tmp_ss - > mac_timestamp ) ;
rtap_position + = RTAP_L_MACTS ;
break ;
case RTAP_FLAGS :
memcpy ( & ( tmp_ss - > flags ) , & data [ rtap_position ] , RTAP_L_FLAGS ) ;
tmp_ss - > check [ RTAP_FLAGS ] = TRUE ;
if ( print_values )
printf ( " Flags : %hu \n " , tmp_ss - > flags ) ;
rtap_position + = RTAP_L_FLAGS ;
break ;
case RTAP_RATE :
memcpy ( & ( tmp_ss - > data_rate ) , & data [ rtap_position ] , RTAP_L_RATE ) ;
tmp_ss - > check [ RTAP_RATE ] = TRUE ;
if ( print_values )
printf ( " Data rate : %hhd MB/s \n " , tmp_ss - > data_rate / 2 ) ;
rtap_position + = RTAP_L_RATE ;
break ;
case RTAP_CHANNEL :
memcpy ( & ( tmp_ss - > channel ) , & data [ rtap_position ] , RTAP_L_CHANNEL ) ;
rtap_position + = RTAP_L_CHANNEL ;
tmp_ss - > check [ RTAP_CHANNEL ] = TRUE ;
memcpy ( & ( tmp_ss - > channel_type ) , & data [ rtap_position ] , RTAP_L_CHANNELTYPE ) ;
if ( print_values )
printf ( " Channel : %hu MHz \n Channel Type : %#06x \n " , tmp_ss - > channel , tmp_ss - > channel_type ) ;
rtap_position + = RTAP_L_CHANNELTYPE ;
break ;
case RTAP_FHSS :
memcpy ( & ( tmp_ss - > fhss ) , & data [ rtap_position ] , RTAP_L_FHSS ) ;
tmp_ss - > check [ RTAP_FHSS ] = TRUE ;
if ( print_values )
printf ( " FHSS : %hu \n " , tmp_ss - > fhss ) ;
rtap_position + = RTAP_L_FHSS ;
break ;
case RTAP_ANTENNASIGNALDBM :
memcpy ( & ( tmp_ss - > antenna_signal_dbm ) , & data [ rtap_position ] , RTAP_L_ANTENNASIGNALDBM ) ;
tmp_ss - > check [ RTAP_ANTENNASIGNALDBM ] = TRUE ;
if ( print_values )
printf ( " Antenna Signal : %d dBm \n " , tmp_ss - > antenna_signal_dbm - 0x100 ) ;
rtap_position + = RTAP_L_ANTENNASIGNALDBM ;
break ;
case RTAP_ANTENNANOISEDBM :
memcpy ( & ( tmp_ss - > antenna_noise_dbm ) , & data [ rtap_position ] , RTAP_L_ANTENNANOISEDBM ) ;
tmp_ss - > check [ RTAP_ANTENNANOISEDBM ] = TRUE ;
if ( print_values )
printf ( " Antenna Noise : %d dBm \n " , tmp_ss - > antenna_noise_dbm - 0x100 ) ;
rtap_position + = RTAP_L_ANTENNANOISEDBM ;
break ;
case RTAP_LOCKQUALITY :
memcpy ( & ( tmp_ss - > lock_quality ) , & data [ rtap_position ] , RTAP_L_LOCKQUALITY ) ;
tmp_ss - > check [ RTAP_LOCKQUALITY ] = TRUE ;
if ( print_values )
printf ( " Lock Quality : %hu \n " , tmp_ss - > lock_quality ) ;
rtap_position + = RTAP_L_LOCKQUALITY ;
break ;
case RTAP_TXATTENUATION :
memcpy ( & ( tmp_ss - > tx_attenuation ) , & data [ rtap_position ] , RTAP_L_TXATTENUATION ) ;
tmp_ss - > check [ RTAP_TXATTENUATION ] = TRUE ;
if ( print_values )
printf ( " Taux Attenuation : %hu \n " , tmp_ss - > tx_attenuation ) ;
rtap_position + = RTAP_L_TXATTENUATION ;
break ;
case RTAP_TXATTENUATIONDB :
memcpy ( & ( tmp_ss - > tx_attenuation_db ) , & data [ rtap_position ] , RTAP_L_TXATTENUATIONDB ) ;
tmp_ss - > check [ RTAP_TXATTENUATIONDB ] = TRUE ;
if ( print_values )
printf ( " Atténuation : %hu dB \n " , tmp_ss - > tx_attenuation_db ) ;
rtap_position + = RTAP_L_TXATTENUATIONDB ;
break ;
case RTAP_TXATTENUATIONDBM :
memcpy ( & ( tmp_ss - > tx_attenuation_dbm ) , & data [ rtap_position ] , RTAP_L_TXATTENUATIONDBM ) ;
tmp_ss - > check [ RTAP_TXATTENUATIONDBM ] = TRUE ;
if ( print_values )
printf ( " Atténuation : %hu dBm \n " , tmp_ss - > tx_attenuation_dbm ) ;
rtap_position + = RTAP_L_TXATTENUATIONDBM ;
break ;
case RTAP_ANTENNA :
memcpy ( & ( tmp_ss - > antenna ) , & data [ rtap_position ] , RTAP_L_ANTENNA ) ;
tmp_ss - > check [ RTAP_ANTENNA ] = TRUE ;
if ( print_values )
printf ( " Antenna : %hhu \n " , tmp_ss - > antenna ) ;
rtap_position + = RTAP_L_ANTENNA ;
break ;
case RTAP_ANTENNASIGNALDB :
memcpy ( & ( tmp_ss - > antenna_signal_db ) , & data [ rtap_position ] , RTAP_L_ANTENNASIGNALDB ) ;
tmp_ss - > check [ RTAP_ANTENNASIGNALDB ] = TRUE ;
if ( print_values )
printf ( " Antenna Signal : %hhu dB \n " , tmp_ss - > antenna_signal_db ) ;
rtap_position + = RTAP_L_ANTENNASIGNALDB ;
break ;
case RTAP_ANTENNANOISEDB :
memcpy ( & ( tmp_ss - > antenna_noise_db ) , & data [ rtap_position ] , RTAP_L_ANTENNANOISEDB ) ;
tmp_ss - > check [ RTAP_ANTENNANOISEDB ] = TRUE ;
if ( print_values )
printf ( " Antenna Noise : %hhu dB \n " , tmp_ss - > antenna_noise_db ) ;
rtap_position + = RTAP_L_ANTENNANOISEDB ;
break ;
case RTAP_FCS :
memcpy ( & ( tmp_ss - > fcs ) , & data [ rtap_position ] , RTAP_L_FCS ) ;
tmp_ss - > check [ RTAP_FCS ] = TRUE ;
if ( print_values )
printf ( " FCS : %lu \n " , tmp_ss - > fcs ) ;
rtap_position + = RTAP_L_FCS ;
break ;
}
}
rtap_presentflags / = 2 ;
}
if ( print_values )
printf ( " \n " ) ;
tmp_mac = * results ;
if ( * results = = NULL ) // Si la liste de résultats n'existe pas encore,
{
tmp_mac = malloc ( sizeof ( mac_list ) ) ; // on la crée.
memcpy ( tmp_mac - > mac_addr_bytes , mac_addr_bytes , 6 ) ;
tmp_mac - > nb_samples = 1 ;
tmp_mac - > next = NULL ;
tmp_mac - > samples_list = tmp_ss ;
* results = tmp_mac ;
}
else
{
while ( tmp_mac ! = NULL )
{
if ( mac_cmp ( mac_addr_bytes , tmp_mac - > mac_addr_bytes ) = = 1 )
break ;
tmp_mac = tmp_mac - > next ;
}
if ( tmp_mac = = NULL )
{
tmp_mac = malloc ( sizeof ( mac_list ) ) ;
memcpy ( tmp_mac - > mac_addr_bytes , mac_addr_bytes , 6 ) ;
tmp_mac - > nb_samples = 1 ;
tmp_mac - > next = * results ;
tmp_mac - > samples_list = tmp_ss ;
* results = tmp_mac ;
}
else
{
tmp_mac - > nb_samples + + ;
tmp_ss - > next = tmp_mac - > samples_list ;
tmp_mac - > samples_list = tmp_ss ;
}
}
}
2008-02-14 09:45:47 +01:00
}
2008-02-22 16:04:49 +01:00
2008-02-14 09:45:47 +01:00
/* Affiche la liste chaînée des résultats */
void print_mac_list ( mac_list * results , BOOL verbose )
{
mac_list * mac_ptr = results ; // Récupère la liste d'adresse MAC en entrée
ss_list * ss_ptr = NULL ; // Initialise la sous-liste
2008-02-22 16:04:49 +01:00
char * mac_string ;
2008-02-14 09:45:47 +01:00
double antenna_signal_average = 0 ; // Moyenne des valeurs récupérées de antenna signal en dBm
double antenna_noise_average = 0 ; // Moyenne des valeurs récupérées de antenna noise en dBm
double data_rate_average = 0 ; // Moyenne du débit
unsigned short channel = - 1 ; // Canal utilisé pour la MAC courante
unsigned short channel_type = - 1 ; // Type de liaison utilisée pour la MAC courante
if ( results = = NULL ) // Si la liste est vide
{
printf ( " Aucun résultat. \n " ) ; // on l'affiche.
return ;
}
while ( mac_ptr ! = NULL )
{
2008-02-22 16:04:49 +01:00
mac_string = mac_bytes_to_string ( mac_ptr - > mac_addr_bytes ) ;
2008-02-14 09:45:47 +01:00
ss_ptr = mac_ptr - > samples_list ; // On récupère le pointeur de la sous-liste
antenna_signal_average = 0 ;
antenna_noise_average = 0 ;
data_rate_average = 0 ;
while ( ss_ptr ! = NULL ) // On parcourt toutes les valeurs de l'affaiblissement en dB et on en fait la moyenne.
{
antenna_signal_average + = pow ( ( double ) 10 , ( ( double ) ( ss_ptr - > antenna_signal_dbm - 0x100 ) / 10 ) ) ; // Il faut le minorer de 256 pour avoir la vrai puissance car sinon codage serai sur plus d'un octet.
antenna_noise_average + = pow ( ( double ) 10 , ( ( double ) ( ss_ptr - > antenna_noise_dbm - 0x100 ) / 10 ) ) ;
data_rate_average + = ( ( ss_ptr - > data_rate ) / 2 ) ;
channel = ss_ptr - > channel ;
channel_type = ss_ptr - > channel_type ;
if ( verbose ) // Affichage du maillon si on est en mode verbeux.
{
2008-02-22 16:04:49 +01:00
printf ( " [%s] \n " , mac_string ) ;
2008-02-14 09:45:47 +01:00
print_ss_list ( ss_ptr ) ;
putchar ( ' \n ' ) ;
}
ss_ptr = ss_ptr - > next ;
}
/* Calcul des moyennes */
antenna_signal_average = 10 * log10 ( ( double ) ( antenna_signal_average / mac_ptr - > nb_samples ) ) ;
antenna_noise_average = 10 * log10 ( ( double ) ( antenna_noise_average / mac_ptr - > nb_samples ) ) ;
data_rate_average / = ( double ) mac_ptr - > nb_samples ;
/* Affichage */
2008-02-22 16:04:49 +01:00
printf ( " [%s] [Canal : %hhd] [Fréquence : %hu MHz] [Type de liaison : %#06x] [Moyenne du débit : %0.1f Mo/s] [Moyenne du signal : %0.1f dBm] [Moyenne du bruit : %0.1f dBm] \n " , mac_string , frequency_to_channel ( channel ) , channel , channel_type , data_rate_average , antenna_signal_average , antenna_noise_average ) ;
2008-02-14 09:45:47 +01:00
if ( verbose )
printf ( " \n \n " ) ;
2008-02-22 16:04:49 +01:00
free ( mac_string ) ;
2008-02-14 09:45:47 +01:00
mac_ptr = mac_ptr - > next ;
}
}
2008-02-22 16:04:49 +01:00
2008-02-14 09:45:47 +01:00
/* Affiche un maillon d'une sous-liste de résultats */
void print_ss_list ( ss_list * ss )
{
if ( ss = = NULL )
return ;
/* Champs statiques */
printf ( " Header revision : %hhu \n " , ss - > header_revision ) ;
printf ( " Header Pad : %hhu \n " , ss - > header_pad ) ;
printf ( " Header Length : %hu \n " , ss - > header_length ) ;
printf ( " Present flags : %#010lx \n " , ss - > present_flags ) ; // Largeur de champ 10 : 2 pour "0x" et 8 pour la valeur.
/* Champs dynamiques */
if ( ss - > check [ RTAP_MACTS ] )
printf ( " Mac timestamp : %llu \n " , ss - > mac_timestamp ) ;
if ( ss - > check [ RTAP_FLAGS ] )
printf ( " Flags : %hu \n " , ss - > flags ) ;
if ( ss - > check [ RTAP_RATE ] )
printf ( " Data rate : %hhd MB/s \n " , ss - > data_rate / 2 ) ;
if ( ss - > check [ RTAP_CHANNEL ] )
printf ( " Channel : %hu MHz \n Channel Type : %#06x \n " , ss - > channel , ss - > channel_type ) ;
if ( ss - > check [ RTAP_FHSS ] )
printf ( " FHSS : %hu \n " , ss - > fhss ) ;
if ( ss - > check [ RTAP_ANTENNASIGNALDBM ] )
printf ( " Antenna Signal : %d dBm \n " , ss - > antenna_signal_dbm - 0x100 ) ;
if ( ss - > check [ RTAP_ANTENNANOISEDBM ] )
printf ( " Antenna Noise : %d dBm \n " , ss - > antenna_noise_dbm - 0x100 ) ;
if ( ss - > check [ RTAP_LOCKQUALITY ] )
printf ( " Lock Quality : %hu \n " , ss - > lock_quality ) ;
if ( ss - > check [ RTAP_TXATTENUATION ] )
printf ( " Taux Attenuation : %hu \n " , ss - > tx_attenuation ) ;
if ( ss - > check [ RTAP_TXATTENUATIONDB ] )
printf ( " Atténuation : %hu dB \n " , ss - > tx_attenuation_db ) ;
if ( ss - > check [ RTAP_TXATTENUATIONDBM ] )
printf ( " Atténuation : %hu dBm \n " , ss - > tx_attenuation_dbm ) ;
if ( ss - > check [ RTAP_ANTENNA ] )
printf ( " Antenna : %hhu \n " , ss - > antenna ) ;
if ( ss - > check [ RTAP_ANTENNASIGNALDB ] )
printf ( " Antenna Signal : %hhu dB \n " , ss - > antenna_signal_db ) ;
if ( ss - > check [ RTAP_ANTENNANOISEDB ] )
printf ( " Antenna Noise : %hhu dB \n " , ss - > antenna_noise_db ) ;
if ( ss - > check [ RTAP_FCS ] )
printf ( " FCS : %lu \n " , ss - > fcs ) ;
}
2008-02-22 16:04:49 +01:00
2008-02-14 09:45:47 +01:00
/* Vide la liste chaînée d'adresse MAC */
void free_mac_list ( mac_list * * results )
{
mac_list * mac_ptr = * results ;
ss_list * ss_ptr = NULL ;
if ( * results ! = NULL )
{
while ( mac_ptr ! = NULL )
{
ss_ptr = mac_ptr - > samples_list ;
while ( ss_ptr ! = NULL )
{
ss_ptr = ss_ptr - > next ;
free ( mac_ptr - > samples_list ) ;
mac_ptr - > samples_list = ss_ptr ;
}
mac_ptr = mac_ptr - > next ;
free ( * results ) ;
* results = mac_ptr ;
}
}
}
2008-02-22 16:04:49 +01:00
2008-02-26 13:29:27 +01:00
/* Enregistre la liste "results" dans le fichier nommé "file" */
2008-02-14 09:45:47 +01:00
int write_mac_list_to_file ( char * file , mac_list * results )
{
int fd = 0 ; // Descripteur de fichier.
mac_list * ptr ; // Tête de lecture de la liste chaînée.
ss_list * ss_ptr ; // Tête de lecture de la sous-liste.
int mac_list_size = sizeof ( mac_list ) ;
int ss_list_size = sizeof ( ss_list ) ;
/* Ouverture du fichier */
fd = open ( file , O_WRONLY | O_CREAT ) ;
if ( fd < 0 )
{
perror ( " Impossible d'ouvrir le fichier de sortie " ) ;
return ERR_OPENING_FILE ;
}
/* Écriture des données */
ptr = results ; // On commence par la tête de la liste (forcément...).
while ( ptr ! = NULL )
{
/* Enregistrement du maillon de la liste principale */
if ( write ( fd , ptr , mac_list_size ) ! = mac_list_size )
perror ( " Erreur d'écriture (mac_list) " ) ;
/* Enregistrement de la sous-liste */
ss_ptr = ptr - > samples_list ;
while ( ss_ptr ! = NULL )
{
if ( write ( fd , ss_ptr , ss_list_size ) ! = ss_list_size ) // Écriture du maillon courant.
perror ( " Erreur d'écriture (ss_list) " ) ;
ss_ptr = ss_ptr - > next ;
}
ptr = ptr - > next ;
}
/* Fermeture du fichier */
if ( close ( fd ) ! = 0 )
2008-02-26 13:29:27 +01:00
{
perror ( " Erreur lors de la fermeture du fichier de sortie " ) ;
return ERR_CLOSING_FILE ;
}
2008-02-14 09:45:47 +01:00
return 0 ;
}
2008-02-22 16:04:49 +01:00
2008-02-26 13:29:27 +01:00
/* Lit le fichier nommé "file" et enregistre la liste lue dans "results" */
2008-02-14 09:45:47 +01:00
int read_mac_list_from_file ( char * file , mac_list * * results )
{
int fd = 0 ; // Descripteur de fichier.
mac_list * ptr = NULL ; // Tête de lecture de la liste chaînée.
ss_list * ss_ptr ; // Tête de lecture de la sous-liste.
ss_list * ss_prev ; // Maillon précédent lors de la lecture.
int mac_list_size = sizeof ( mac_list ) ;
int ss_list_size = sizeof ( ss_list ) ;
mac_list mac_list_lu ;
ss_list ss_list_lu ;
/* Ouverture du fichier */
fd = open ( file , O_RDONLY ) ;
if ( fd < 0 )
{
perror ( " Impossible d'ouvrir le fichier d'entrée " ) ;
return ERR_OPENING_FILE ;
}
/* Lecture des données */
while ( read ( fd , & mac_list_lu , mac_list_size ) = = mac_list_size ) // Lecture du premier champ
{
/* Allocation du maillon courant */
if ( * results = = NULL )
{
* results = malloc ( mac_list_size ) ; // Création de la liste
ptr = * results ;
}
else
{
ptr - > next = malloc ( mac_list_size ) ; // Création du maillon suivant
ptr = ptr - > next ;
}
* ptr = mac_list_lu ;
/* Lecture de la sous-liste */
ss_prev = NULL ;
ss_ptr = ptr - > samples_list ;
while ( ss_ptr ! = NULL )
{
if ( read ( fd , & ss_list_lu , ss_list_size ) ! = ss_list_size ) // Lecture d'un maillon ss_list.
perror ( " Erreur de lecture (ss_list) " ) ;
else // Si on a bien lu un maillon entier :
{
if ( ss_prev = = NULL ) // Si c'est le premier maillon,
{
ptr - > samples_list = malloc ( ss_list_size ) ; // allocation du premier maillon.
ss_ptr = ptr - > samples_list ;
}
else // Si ce n'est pas le premier maillon,
{
ss_prev - > next = malloc ( ss_list_size ) ; // allocation d'un nouveau maillon.
ss_ptr = ss_prev - > next ;
}
* ss_ptr = ss_list_lu ;
ss_prev = ss_ptr ;
ss_ptr = ss_ptr - > next ;
}
}
if ( ss_prev ! = NULL )
ss_prev - > next = NULL ;
}
2008-02-22 16:04:49 +01:00
2008-02-14 09:45:47 +01:00
if ( ptr ! = NULL )
ptr - > next = NULL ;
/* Fermeture du fichier */
if ( close ( fd ) ! = 0 )
perror ( " Erreur lors de la fermeture du fichier de sortie " ) ;
return 0 ;
}
2008-02-26 13:29:27 +01:00
/* Enregistre la liste "results" dans le fichier nommé "file", au format texte */
int write_mac_list_to_text_file ( char * file , mac_list * results , char direction , float pos_x , float pos_y , float pos_z )
{
FILE * fd = NULL ; // Descripteur de fichier.
mac_list * ptr ; // Tête de lecture de la liste chaînée.
ss_list * ss_ptr ; // Tête de lecture de la sous-liste.
/* Ouverture du fichier */
fd = fopen ( file , " a " ) ; // Ouverture du fichier de sortie en ajout
if ( fd = = NULL ) // Si ouverture échouée,
{
perror ( " Impossible d'ouvrir le fichier de sortie " ) ;
fprintf ( stderr , " Redirection de la sortie sur la sortie standard. " ) ;
fd = stdout ; // on redirige sur stdout
}
/* Écriture des données */
ptr = results ; // On commence par la tête de la liste (forcément...).
while ( ptr ! = NULL )
{
char * mac_string ;
/* Enregistrement des données fixes */
fprintf ( fd , " %0.2f;%0.2f;%0.2f;%hhd " , pos_x , pos_y , pos_z , direction ) ;
/* Enregistrement du maillon de la liste principale */
mac_string = mac_bytes_to_string ( ptr - > mac_addr_bytes ) ;
fprintf ( fd , " ;%s " , mac_string ) ;
/* Enregistrement de la sous-liste */
ss_ptr = ptr - > samples_list ;
while ( ss_ptr ! = NULL )
{
fprintf ( fd , " ;%d " , ss_ptr - > antenna_signal_dbm - 0x100 ) ; // Écriture de la puissance du signal
ss_ptr = ss_ptr - > next ;
}
fprintf ( fd , " \n " ) ;
free ( mac_string ) ;
ptr = ptr - > next ;
}
/* Fermeture du fichier */
if ( fclose ( fd ) ! = 0 )
{
perror ( " Erreur lors de la fermeture du fichier de sortie " ) ;
return ERR_CLOSING_FILE ;
}
return 0 ;
}