Delete mobile-centred
Delete the old mobile-centred infrastructure.
This commit is contained in:
Matteo Cypriani
parent
0b744995f4
commit
c97ad877e1
21
Makefile
21
Makefile
|
|
@ -1,8 +1,8 @@
|
|||
.PHONY : all libowlps owlps-positioning clean purge help install install-libowlps install-infrastructure-centred install-mobile-centred uninstall uninstall-libowlps uninstall-infrastructure-centred uninstall-mobile-centred
|
||||
.PHONY : all libowlps owlps-positioning clean purge help install install-libowlps install-infrastructure-centred uninstall uninstall-libowlps uninstall-infrastructure-centred
|
||||
|
||||
## Compilation ##
|
||||
|
||||
all : libowlps owlps-positioning infrastructure-centred mobile-centred
|
||||
all : libowlps owlps-positioning infrastructure-centred
|
||||
|
||||
libowlps :
|
||||
@make -C libowlps
|
||||
|
|
@ -13,12 +13,9 @@ owlps-positioning :
|
|||
infrastructure-centred : libowlps
|
||||
@make -C infrastructure-centred
|
||||
|
||||
mobile-centred : libowlps
|
||||
@make -C mobile-centred
|
||||
|
||||
## Installation ##
|
||||
|
||||
install : install-libowlps install-owlps-positioning install-infrastructure-centred install-mobile-centred
|
||||
install : install-libowlps install-owlps-positioning install-infrastructure-centred
|
||||
|
||||
install-libowlps :
|
||||
@make -C libowlps install
|
||||
|
|
@ -29,14 +26,11 @@ install-owlps-positioning :
|
|||
install-infrastructure-centred : install-libowlps
|
||||
@make -C infrastructure-centred install
|
||||
|
||||
install-mobile-centred : install-libowlps
|
||||
@make -C mobile-centred install
|
||||
|
||||
## Désinstallation ##
|
||||
|
||||
uninstall : uninstall-libowlps uninstall-infrastructure-centred uninstall-mobile-centred
|
||||
uninstall : uninstall-libowlps uninstall-infrastructure-centred
|
||||
|
||||
uninstall-libowlps : uninstall-infrastructure-centred uninstall-mobile-centred
|
||||
uninstall-libowlps : uninstall-infrastructure-centred
|
||||
@make -C libowlps uninstall
|
||||
|
||||
uninstall-owlps-positioning :
|
||||
|
|
@ -45,22 +39,17 @@ uninstall-owlps-positioning :
|
|||
uninstall-infrastructure-centred :
|
||||
@make -C infrastructure-centred uninstall
|
||||
|
||||
uninstall-mobile-centred :
|
||||
@make -C mobile-centred uninstall
|
||||
|
||||
## Nettoyage ##
|
||||
|
||||
clean :
|
||||
@make -C libowlps clean
|
||||
@make -C owlps-positioning clean
|
||||
@make -C infrastructure-centred clean
|
||||
@make -C mobile-centred clean
|
||||
|
||||
purge :
|
||||
@make -C libowlps purge
|
||||
@make -C owlps-positioning purge
|
||||
@make -C infrastructure-centred purge
|
||||
@make -C mobile-centred purge
|
||||
|
||||
## Aide ##
|
||||
|
||||
|
|
|
|||
6
TODO
6
TODO
|
|
@ -61,9 +61,3 @@
|
|||
- Do something about that
|
||||
° Merge in owlps-positioning?
|
||||
° Delete?
|
||||
|
||||
|
||||
* mobile-centred
|
||||
|
||||
- Has its own TODO file.
|
||||
- Maybe we should delete that.
|
||||
|
|
|
|||
|
|
@ -1,63 +0,0 @@
|
|||
.PHONY : all librtapscanmob mobile clean purge help install install-librtapscanmob install-mobile uninstall uninstall-librtapscanmob uninstall-mobile
|
||||
|
||||
## Compilation ##
|
||||
|
||||
all : librtapscanmob mobile
|
||||
|
||||
librtapscanmob :
|
||||
@make -C librtapscanmob
|
||||
|
||||
mobile :
|
||||
@make -C mobile
|
||||
|
||||
## Installation ##
|
||||
|
||||
install : install-librtapscanmob install-mobile
|
||||
|
||||
install-librtapscanmob :
|
||||
@make -C librtapscanmob install
|
||||
|
||||
install-mobile : install-librtapscanmob
|
||||
@make -C mobile install
|
||||
|
||||
## Désinstallation ##
|
||||
|
||||
uninstall : uninstall-librtapscanmob uninstall-mobile
|
||||
|
||||
uninstall-librtapscanmob : uninstall-mobile
|
||||
@make -C librtapscanmob uninstall
|
||||
|
||||
uninstall-mobile :
|
||||
@make -C mobile uninstall
|
||||
|
||||
## Nettoyage ##
|
||||
|
||||
clean :
|
||||
@make -C librtapscanmob clean
|
||||
@make -C mobile clean
|
||||
|
||||
purge :
|
||||
@make -C librtapscanmob purge
|
||||
@make -C mobile purge
|
||||
|
||||
## Aide ##
|
||||
|
||||
help :
|
||||
@echo "Bibliothèques nécessaires à la compilation :\n\
|
||||
libpcap0.8-dev\n\
|
||||
librtaputil1.0 (fournie)\n\
|
||||
\n\
|
||||
Cibles possibles :\n\
|
||||
all (cible par défaut) : Compile tous les modules.\n\
|
||||
<module> : Compile uniquement le module <module> (et ses dépendances).\n\
|
||||
\n\
|
||||
install : Installe tous les modules.\n\
|
||||
install-<module> : Installe uniquement le module <module> (et ses dépendances).\n\
|
||||
\n\
|
||||
uninstall : Désinstalle tous les modules.\n\
|
||||
uninstall-<module> : Désinstalle uniquement le module <module> (et ses dépendances).\n\
|
||||
\n\
|
||||
clean : Supprime les fichiers temporaires.\n\
|
||||
purge : Supprime le résultat de la compilation.\n\
|
||||
\n\
|
||||
Note : l'installation se fait dans l'arborescence /usr/local. Modifiez la variable PREFIX de chaque Makefile pour changer ce comportement."
|
||||
|
|
@ -1,2 +0,0 @@
|
|||
* Mettre l'interface Wi-Fi en paramètre du programme mobile.
|
||||
* Envoyer les requêtes en broadcast.
|
||||
|
|
@ -1,134 +0,0 @@
|
|||
# Répertoire d'installation
|
||||
PREFIX=/usr/local
|
||||
INSTALL_DIR= $(PREFIX)/sbin
|
||||
INSTALL_LIB= $(PREFIX)/lib
|
||||
INSTALL_INC= $(PREFIX)/include
|
||||
INSTALL_MAN= $(PREFIX)/share/man
|
||||
|
||||
# Compilateur
|
||||
CC = gcc
|
||||
|
||||
# Autres outils
|
||||
AR = ar
|
||||
RANLIB = ranlib
|
||||
|
||||
# Commandes d'installation et de désinstallation
|
||||
RM=rm -fv
|
||||
CP=cp -v
|
||||
|
||||
# Variables générales
|
||||
LIB_CIBLE=librtapscanmob
|
||||
VERSION=1.0
|
||||
|
||||
# Cibles à construire
|
||||
STATIC=$(LIB_CIBLE).a
|
||||
DYNAMIC=$(LIB_CIBLE).so.$(VERSION)
|
||||
HEADER=rtapscanmob.h
|
||||
#HEADERS=
|
||||
|
||||
# Composition de la bibliothèque
|
||||
OBJS=$(LIB_CIBLE).o
|
||||
|
||||
# Flags
|
||||
CFLAGS=-O2 -W -Wall -Wstrict-prototypes -I.
|
||||
DEPFLAGS=-MMD
|
||||
XCFLAGS=$(CFLAGS) $(DEPFLAGS) $(WARN) $(HEADERS)
|
||||
PICFLAG=-fPIC
|
||||
LIBS=-lm -lpcap
|
||||
|
||||
#STRIPFLAGS= -Wl,-s
|
||||
|
||||
|
||||
## Cibles de compilation standard ##
|
||||
|
||||
all : dynamic static $(PROGS)
|
||||
dynamic : $(DYNAMIC)
|
||||
static : $(STATIC)
|
||||
|
||||
% : %.o
|
||||
$(CC) $(LDFLAGS) $(STRIPFLAGS) $(XCFLAGS) -o $@ $^
|
||||
%.o : %.c $(HEADER)
|
||||
$(CC) $(XCFLAGS) -c $<
|
||||
%.so : %.c $(HEADER)
|
||||
$(CC) $(XCFLAGS) $(PICFLAG) -c -o $@ $<
|
||||
|
||||
# Compilation de la bibliothèque dynamique
|
||||
$(DYNAMIC) : $(OBJS:.o=.so)
|
||||
$(CC) -shared -o $@ -Wl,-soname,$@ $(STRIPFLAGS) $(LIBS) -lc $^
|
||||
|
||||
# Compilation de la bibliothèque statique
|
||||
$(STATIC) : $(OBJS:.o=.so)
|
||||
$(RM) $@
|
||||
$(AR) cru $@ $^
|
||||
$(RANLIB) $@
|
||||
|
||||
|
||||
## Installation ##
|
||||
|
||||
install : install-static install-dynamic
|
||||
|
||||
install-dynamic : install-header $(DYNAMIC)
|
||||
@$(CP) $(DYNAMIC) $(INSTALL_LIB) &&\
|
||||
chmod 644 $(INSTALL_LIB)/$(DYNAMIC) &&\
|
||||
chown root:root $(INSTALL_LIB)/$(DYNAMIC) &&\
|
||||
echo "Reconstruction du cache pour ld.so : ldconfig $(INSTALL_LIB)" ; ldconfig $(INSTALL_LIB)
|
||||
|
||||
install-static : install-header $(STATIC)
|
||||
@$(CP) $(STATIC) $(INSTALL_LIB) &&\
|
||||
chmod 644 $(INSTALL_LIB)/$(STATIC) &&\
|
||||
chown root:root $(INSTALL_LIB)/$(STATIC)
|
||||
|
||||
install-header : $(HEADER)
|
||||
@$(CP) $(HEADER) $(INSTALL_INC) &&\
|
||||
chmod 644 $(INSTALL_INC)/$(HEADER) &&\
|
||||
chown root:root $(INSTALL_INC)/$(HEADER)
|
||||
|
||||
|
||||
## Désinstallation ##
|
||||
|
||||
uninstall : uninstall-static uninstall-dynamic
|
||||
|
||||
uninstall-dynamic : uninstall-header
|
||||
@$(RM) $(INSTALL_LIB)/$(DYNAMIC)
|
||||
@echo "Reconstruction du cache pour ld.so : ldconfig" ; ldconfig
|
||||
|
||||
uninstall-static : uninstall-header
|
||||
@$(RM) $(INSTALL_LIB)/$(STATIC)
|
||||
|
||||
uninstall-header :
|
||||
@$(RM) $(INSTALL_INC)/$(HEADER)
|
||||
|
||||
|
||||
## Nettoyage ##
|
||||
|
||||
clean :
|
||||
@$(RM) *~ *.o $(LIB_CIBLE).so *.d
|
||||
|
||||
purge : clean
|
||||
@$(RM) $(DYNAMIC) $(STATIC) $(PROGS)
|
||||
|
||||
|
||||
## Aide ##
|
||||
|
||||
help :
|
||||
@echo -e "Bibliothèques nécessaires à la compilation :\n\
|
||||
libpcap0.8-dev\n\
|
||||
libowlps1.0 (fournie)\n\
|
||||
\n\
|
||||
Cibles possibles :\n\
|
||||
all (cible par défaut) : Compile la bibliothèque partagée et statique.\n\
|
||||
dynamic : Compile la bibilothèque partagée (.so).\n\
|
||||
static : Compile la bibliothèque statique (.a).\n\
|
||||
\n\
|
||||
install : Installe la bibliothèque partagée et statique.\n\
|
||||
install-dynamic : N'installe que la bibliothèque partagée.\n\
|
||||
install-static : N'installe que la bibliothèque statique.\n\
|
||||
\n\
|
||||
uninstall : Désinstalle tout ce qu'il est possible de désinstaller.\n\
|
||||
uninstall-dynamic : Désinstalle la bibliothèque partagée.\n\
|
||||
uninstall-static : Désinstalle la bibliothèque statique.\n\
|
||||
\n\
|
||||
clean : Supprime les fichiers temporaires.\n\
|
||||
purge : Supprime le résultat de la compilation.\n\
|
||||
\n\
|
||||
Note : l'installation se fait dans l'arborescence $(PREFIX). Modifiez la variable PREFIX du Makefile pour changer ce comportement."
|
||||
|
|
@ -1,601 +0,0 @@
|
|||
/*
|
||||
* This is the rtapanalyser library, Wi-Fi packet sniffer and analyser,
|
||||
* thanks to the radiotap header of each packet.
|
||||
*/
|
||||
|
||||
|
||||
#include "rtapscanmob.h"
|
||||
|
||||
|
||||
|
||||
BOOL run = TRUE ;
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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)
|
||||
{
|
||||
pcap_t *handle ; // Descripteur de capture de paquets
|
||||
char errbuf[PCAP_ERRBUF_SIZE] ; // Message d'erreur
|
||||
TIMESTAMP 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.
|
||||
}
|
||||
|
||||
|
||||
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é ?
|
||||
{
|
||||
fprintf(stderr, "Impossible d'ouvrir l'interface « %s » : %s\n", capture_iface, errbuf) ;
|
||||
return ERR_OPENING_IFACE ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
if (capture_time > 0) // Si le temps de capture est positif
|
||||
{
|
||||
timestamp_now(&tbegin) ; // Récupère l'heure courante (heure du lancement de la capture)
|
||||
|
||||
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
|
||||
|
||||
timestamp_now(&tcurrent) ; // Récupère l'heure courante
|
||||
if (time_elapsed(tcurrent, tbegin) > capture_time) // Si le temps de capture est écoulé
|
||||
break ; // on arrête la collecte.
|
||||
}
|
||||
}
|
||||
|
||||
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 ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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)
|
||||
{
|
||||
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\nChannel 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_equals(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 ;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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
|
||||
char *mac_string ;
|
||||
|
||||
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)
|
||||
{
|
||||
mac_string = mac_bytes_to_string(mac_ptr->mac_addr_bytes) ;
|
||||
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.
|
||||
{
|
||||
printf("[%s]\n", mac_string) ;
|
||||
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 */
|
||||
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) ;
|
||||
if (verbose)
|
||||
printf("\n\n") ;
|
||||
|
||||
free(mac_string) ;
|
||||
mac_ptr = mac_ptr->next ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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\nChannel 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) ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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 ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* Enregistre la liste "results" dans le fichier nommé "file" */
|
||||
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)
|
||||
{
|
||||
perror("Erreur lors de la fermeture du fichier de sortie ") ;
|
||||
return ERR_CLOSING_FILE ;
|
||||
}
|
||||
|
||||
return 0 ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* Lit le fichier nommé "file" et enregistre la liste lue dans "results" */
|
||||
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 ;
|
||||
}
|
||||
|
||||
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 ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
/* 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 ;
|
||||
}
|
||||
|
|
@ -1,73 +0,0 @@
|
|||
/*
|
||||
* This is the rtapanalyser library, Wi-Fi packet sniffer and analyser,
|
||||
* thanks to the radiotap header of each packet.
|
||||
*/
|
||||
|
||||
#ifndef _LIB_RTAPSCANMOB_H
|
||||
#define _LIB_RTAPSCANMOB_H
|
||||
|
||||
|
||||
#include <pcap.h>
|
||||
|
||||
#include "../../libowlps/owlps.h"
|
||||
|
||||
|
||||
|
||||
/* Liste chaînée des valeurs des champs rtap */
|
||||
typedef struct _ss_list
|
||||
{
|
||||
unsigned char header_revision ;
|
||||
unsigned char header_pad ;
|
||||
unsigned short header_length ;
|
||||
unsigned short fhss;
|
||||
unsigned long present_flags ;
|
||||
unsigned long long mac_timestamp ;
|
||||
unsigned char flags;
|
||||
unsigned char data_rate ;
|
||||
unsigned short channel ;
|
||||
unsigned short channel_type ;
|
||||
unsigned char antenna_signal_dbm ;
|
||||
unsigned char antenna_noise_dbm ;
|
||||
unsigned char antenna ;
|
||||
unsigned short lock_quality ;
|
||||
unsigned short tx_attenuation ;
|
||||
unsigned short tx_attenuation_db ;
|
||||
unsigned char tx_attenuation_dbm ;
|
||||
unsigned char antenna_signal_db ;
|
||||
unsigned char antenna_noise_db ;
|
||||
unsigned long fcs ;
|
||||
BOOL check[15] ; // Champs présents
|
||||
struct _ss_list *next ;
|
||||
} ss_list ;
|
||||
|
||||
|
||||
/* Liste chaînée des adresses MAC en provenances desquelles on a capturé des paquets */
|
||||
typedef struct _mac_list
|
||||
{
|
||||
unsigned short int nb_samples ; // Nombre d'occurrences de l'adresse MAC
|
||||
unsigned char mac_addr_bytes[6] ; // Adresse MAC en octets
|
||||
ss_list *samples_list ; // Liste des valeurs capturées pour cette adresse
|
||||
struct _mac_list *next ; // Élément suivant de la liste
|
||||
} mac_list ;
|
||||
|
||||
|
||||
/* Codes d'erreurs */
|
||||
#define ERR_FILENAME 1 // Erreur dans le nom du fichier d'entrée ou de sortie
|
||||
#define ERR_OPENING_FILE 2 // Erreur lors de l'ouverture du fichier d'entrée ou de sortie
|
||||
#define ERR_OPENING_IFACE 3 // Erreur lors de l'ouverture de l'interface de capture
|
||||
#define ERR_CAPTURE_TIME_FORMAT 4 // Format du temps de capture incorrect
|
||||
#define ERR_CLOSING_FILE 5 // Erreur lors de la fermeture du fichier de sortie
|
||||
|
||||
|
||||
/* En-têtes des fonctions */
|
||||
int capture(char *capture_iface, unsigned long capture_time, mac_list **results, BOOL print_values) ;
|
||||
void read_packet(u_char *args, const struct pcap_pkthdr *header, const u_char *packet, mac_list **results, BOOL print_values) ;
|
||||
void print_mac_list(mac_list *results, BOOL verbose) ;
|
||||
void print_ss_list(ss_list *ss) ;
|
||||
void free_mac_list(mac_list **results) ;
|
||||
int write_mac_list_to_file(char *file, mac_list *results) ;
|
||||
int read_mac_list_from_file(char *file, mac_list **results) ;
|
||||
int write_mac_list_to_text_file(char *file, mac_list *results, char direction, float pos_x, float pos_y, float pos_z) ;
|
||||
|
||||
|
||||
#endif
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
# Répertoire d'installation
|
||||
PREFIX=/usr/local
|
||||
INSTALL_DIR= $(PREFIX)/sbin
|
||||
INSTALL_LIB= $(PREFIX)/lib
|
||||
INSTALL_INC= $(PREFIX)/include
|
||||
INSTALL_MAN= $(PREFIX)/share/man
|
||||
|
||||
# Compilateur
|
||||
CC = gcc
|
||||
|
||||
# Commandes d'installation et de désinstallation
|
||||
RM=rm -fv
|
||||
CP=cp -v
|
||||
|
||||
# Cible
|
||||
TARGET=mobile
|
||||
HEADER=
|
||||
|
||||
# Flags
|
||||
CFLAGS=-O2 -W -Wall -Wstrict-prototypes -O -I.
|
||||
DEPFLAGS=-MMD
|
||||
XCFLAGS=$(CFLAGS) $(DEPFLAGS) $(WARN) $(HEADERS)
|
||||
PICFLAG=-fPIC
|
||||
LIBS=../../libowlps/libowlps.so.1.0 ../librtapscanmob/librtapscanmob.so.1.0
|
||||
|
||||
|
||||
## Cibles de compilation standard ##
|
||||
|
||||
.PHONY : all install uninstall clean purge help
|
||||
|
||||
all : $(TARGET)
|
||||
|
||||
% : %.o
|
||||
$(CC) $(LDFLAGS) $(STRIPFLAGS) $(XCFLAGS) -o $@ $^ $(LIBS)
|
||||
%.o : %.c $(HEADER)
|
||||
$(CC) $(XCFLAGS) -c $<
|
||||
|
||||
# Compilation du programme
|
||||
$(TARGET) : $(TARGET).o $(HEADER)
|
||||
|
||||
|
||||
## Installation / désinstallation ##
|
||||
|
||||
install : $(TARGET)
|
||||
@$(CP) $(TARGET) $(INSTALL_DIR)
|
||||
@cd $(INSTALL_DIR) ; chown root:root $(TARGET) ; chmod 755 $(TARGET)
|
||||
|
||||
uninstall :
|
||||
@$(RM) $(INSTALL_DIR)/$(TARGET)
|
||||
|
||||
|
||||
## Nettoyage ##
|
||||
|
||||
clean :
|
||||
@$(RM) -fv *~ *.o *.d
|
||||
|
||||
purge : clean
|
||||
@$(RM) -fv $(TARGET)
|
||||
|
||||
|
||||
## Aide ##
|
||||
|
||||
help :
|
||||
@echo "Bibliothèques nécessaires à la compilation :\n\
|
||||
librtaputil1.0 (fournie)\n\
|
||||
librtapscanmob1.0 (fournie)\n\
|
||||
\n\
|
||||
Cibles possibles :\n\
|
||||
$(TARGET) (cible par défaut) : Compile le programme $(TARGET).\n\
|
||||
install : Installe le programme $(TARGET).\n\
|
||||
uninstall : Désinstalle le programme $(TARGET).\n\
|
||||
clean : Supprime les fichiers temporaires.\n\
|
||||
purge : Supprime le résultat de la compilation.\n\
|
||||
\n\
|
||||
Note : l'installation se fait dans l'arborescence $(PREFIX). Modifiez la variable PREFIX du Makefile pour changer ce comportement."
|
||||
|
|
@ -1,274 +0,0 @@
|
|||
/*
|
||||
* This is the rtapanalyser library, Wi-Fi packet sniffer and analyser,
|
||||
* thanks to the radiotap header of each packet.
|
||||
*/
|
||||
|
||||
|
||||
#include "../librtapscanmob/rtapscanmob.h"
|
||||
|
||||
|
||||
|
||||
/* Options du programme */
|
||||
#define DEFAULT_IFACE "rtap0" // Interface de capture par défaut.
|
||||
#define DEFAULT_CAPTURE_TIME 5000 // Temps de capture par défaut en milli-secondes.
|
||||
#define MAX_FILENAME_LENGTH 500 // Longueur maximale du nom des fichiers.
|
||||
#define MAX_OPT_LENGTH 6 // Longueur maximale des options sur la ligne de commandes.
|
||||
#define NB_OPTIONS 11 // Nombre d'options.
|
||||
enum {NUM_OPT_HELP, NUM_OPT_IFACE, NUM_OPT_CAPTURE_TIME, NUM_OPT_OUTPUT, NUM_OPT_INPUT, NUM_OPT_VERB, NUM_OPT_VERB2, NUM_OPT_DIRECTION, NUM_OPT_POSX, NUM_OPT_POSY, NUM_OPT_POSZ} ; // Liste des numéros d'options.
|
||||
#define OPT_HELP "-h" // Option d'affichage de l'aide.
|
||||
#define OPT_OUTPUT "-o" // Option d'enregistrement des résultats dans un fichier.
|
||||
#define OPT_INPUT "-i" // Option de lecture des trames enregistrées avec -o.
|
||||
#define OPT_IFACE "-d" // Option de spécification de l'interface de capture.
|
||||
#define OPT_CAPTURE_TIME "-t" // Option de spécification du temps de capture.
|
||||
#define OPT_VERB "-v" // Option de verbosité.
|
||||
#define OPT_VERB2 "-vv" // Option de verbosité maximale.
|
||||
#define OPT_DIRECTION "-dir" // Option de calibration (direction).
|
||||
#define OPT_POSX "-posx" // Option de calibration (position en X).
|
||||
#define OPT_POSY "-posy" // Option de calibration (position en Y).
|
||||
#define OPT_POSZ "-posz" // Option de calibration (position en Z).
|
||||
#define ERR_BAD_OPTION 50 // Code d'erreur en cas de mauvaise option de ligne de commande.
|
||||
#define ERR_OPT_INPUT_OUTPUT 51 // Erreur d'incompatibilité entre les deux options entrée et sortie de/vers fichier.
|
||||
#define ERR_OPT_CALIBRATION 52 // Erreur si toutes les options de calibration ne sont pas présentes.
|
||||
|
||||
|
||||
|
||||
/* Affiche la syntaxe du programme */
|
||||
void print_usage(char *prog)
|
||||
{
|
||||
printf("Usage :\n\
|
||||
\t%s -h\n\
|
||||
\t%s [ -v ] [ -i fichier ]\n\
|
||||
\t%s [ -v | -vv ] [ -d interface ] [ -t temps ] [ -o fichier ] [ -dir direction -posx x -posy y -posz z ]\n\
|
||||
", prog, prog, prog) ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Affiche la syntaxe du programme */
|
||||
void print_usage_only(char *prog)
|
||||
{
|
||||
putchar('\n') ;
|
||||
|
||||
print_usage(prog) ;
|
||||
|
||||
printf("\nPour afficher l'aide, tapez « %s -h ».\n", prog) ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Affiche l'aide complète du programme */
|
||||
void print_help(char *prog)
|
||||
{
|
||||
print_usage(prog) ;
|
||||
|
||||
printf("\n\
|
||||
Options :\n\
|
||||
\t-h : affiche cette aide.\n\
|
||||
\t-v : affichage détaillé.\n\
|
||||
\t-vv : affichage très détaillé.\n\
|
||||
\t-i fichier : lit les informations depuis le fichier « fichier » plutôt que de tenter de capturer des paquets.\n\
|
||||
\t-o fichier : enregistre les informations capturées dans le fichier « fichier ».\n\
|
||||
\t-d interface : les paquets sont capturés sur l'interface réseau « interface ». Par défaut, « %s » est utilisée.\n\
|
||||
\t-t temps : les paquets sont capturés pendant « temps » millisecondes. Par défaut, « temps » vaut %d.\n\
|
||||
\t-dir direction : dans le cas de la calibration, indique que la mesure est effectuée vers « direction » (entier de 1 à 4).\n\
|
||||
\t-posx x : dans le cas de la calibration, indique que la position en X du mobile est « x » (flottant).\n\
|
||||
\t-posy y : dans le cas de la calibration, indique que la position en Y du mobile est « y » (flottant).\n\
|
||||
\t-posz z : dans le cas de la calibration, indique que la position en Z du mobile est « z » (flottant).\n\
|
||||
\n\
|
||||
Note : votre interface de capture doit être en mode « monitor », et supporter radiotap.\n\
|
||||
", DEFAULT_IFACE, DEFAULT_CAPTURE_TIME) ;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/* Analyse les options de la ligne de commandes */
|
||||
void read_options(int argc, char **argv, BOOL *options, char *capture_iface, int *capture_time, char *file, char *direction, float *pos_x, float *pos_y, float *pos_z)
|
||||
{
|
||||
int i ; // Compteur.
|
||||
char num_prev_opt = -1 ; // Numéro de la dernière option lue, si elle prend un argument. Ne doit pas être positionné lors de la lecture des options ne prenant pas d'argument ; doit être repositionnée à -1 après le traitement de l'option.
|
||||
|
||||
|
||||
/* Initialisation du tableau d'options à FALSE */
|
||||
for (i = 0 ; i < NB_OPTIONS ; i++)
|
||||
options[i] = FALSE ;
|
||||
|
||||
|
||||
/* Lecture des options */
|
||||
for (i = 1 ; i < argc ; i++)
|
||||
{
|
||||
if (num_prev_opt != -1)
|
||||
{
|
||||
/* Cas des options suivies d'un argument (exemple : « -o fichier ») */
|
||||
switch (num_prev_opt)
|
||||
{
|
||||
case NUM_OPT_OUTPUT :
|
||||
case NUM_OPT_INPUT :
|
||||
strncpy(file, argv[i], MAX_FILENAME_LENGTH) ;
|
||||
break ;
|
||||
case NUM_OPT_IFACE :
|
||||
strncpy(capture_iface, argv[i], IFNAMSIZ) ;
|
||||
break ;
|
||||
case NUM_OPT_CAPTURE_TIME :
|
||||
*capture_time = atoi(argv[i]) ;
|
||||
break ;
|
||||
case NUM_OPT_DIRECTION :
|
||||
*direction = atoi(argv[i]) ;
|
||||
break ;
|
||||
case NUM_OPT_POSX :
|
||||
*pos_x = atof(argv[i]) ;
|
||||
break ;
|
||||
case NUM_OPT_POSY :
|
||||
*pos_y = atof(argv[i]) ;
|
||||
break ;
|
||||
case NUM_OPT_POSZ :
|
||||
*pos_z = atof(argv[i]) ;
|
||||
break ;
|
||||
}
|
||||
num_prev_opt = -1 ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_HELP, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
print_help(argv[0]) ;
|
||||
exit(0) ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_IFACE, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_IFACE] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_IFACE ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_CAPTURE_TIME, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_CAPTURE_TIME] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_CAPTURE_TIME ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_OUTPUT, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_OUTPUT] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_OUTPUT ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_INPUT, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_INPUT] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_INPUT ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_VERB, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
if (options[NUM_OPT_VERB] == TRUE) // Si l'option est déjà présente,
|
||||
options[NUM_OPT_VERB2] = TRUE ; // on active le deuxième niveau de verbosité.
|
||||
else
|
||||
options[NUM_OPT_VERB] = TRUE ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_VERB2, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_VERB] = TRUE ;
|
||||
options[NUM_OPT_VERB2] = TRUE ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_DIRECTION, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_DIRECTION] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_DIRECTION ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_POSX, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_POSX] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_POSX ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_POSY, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_POSY] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_POSY ;
|
||||
}
|
||||
|
||||
else if (strncmp(argv[i], OPT_POSZ, MAX_OPT_LENGTH) == 0)
|
||||
{
|
||||
options[NUM_OPT_POSZ] = TRUE ;
|
||||
num_prev_opt = NUM_OPT_POSZ ;
|
||||
}
|
||||
|
||||
else
|
||||
{
|
||||
print_usage_only(argv[0]) ;
|
||||
fprintf(stderr, "Option inconnue « %s » !\n\n", argv[i]) ;
|
||||
exit(ERR_BAD_OPTION) ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* Vérifications des options */
|
||||
if (options[NUM_OPT_OUTPUT] == TRUE || options[NUM_OPT_INPUT] == TRUE)
|
||||
if (file[0] == '\0')
|
||||
{
|
||||
fprintf(stderr, "Vous devez spécifier un nom de fichier après les options -i et -o !\n") ;
|
||||
print_usage_only(argv[0]) ;
|
||||
exit(ERR_FILENAME) ;
|
||||
}
|
||||
if (options[NUM_OPT_OUTPUT] == TRUE && options[NUM_OPT_INPUT] == TRUE)
|
||||
{
|
||||
fprintf(stderr, "Les options -i et -o sont incompatibles !\n") ;
|
||||
print_usage_only(argv[0]) ;
|
||||
exit(ERR_OPT_INPUT_OUTPUT) ;
|
||||
}
|
||||
if ((options[NUM_OPT_DIRECTION] || options[NUM_OPT_POSX] || options[NUM_OPT_POSY] || options[NUM_OPT_POSZ]) && ! (options[NUM_OPT_DIRECTION] && options[NUM_OPT_POSX] && options[NUM_OPT_POSY] && options[NUM_OPT_POSZ]))
|
||||
{
|
||||
fprintf(stderr, "Vous devez spécifier toutes les options de calibration ou aucune !\n") ;
|
||||
print_usage_only(argv[0]) ;
|
||||
exit(ERR_OPT_CALIBRATION) ;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
BOOL options[NB_OPTIONS] ; // Tableau des options présentes.
|
||||
char capture_iface[IFNAMSIZ] = DEFAULT_IFACE ; // Interface d'entrée
|
||||
int capture_time = DEFAULT_CAPTURE_TIME ; // Temps de capture
|
||||
char file[MAX_FILENAME_LENGTH] = "\0" ; // Nom du fichier à lire ou écrire.
|
||||
char direction = 0 ; // Direction de la calibration.
|
||||
float pos_x = 0, pos_y = 0, pos_z = 0 ; // Positions de la calibration.
|
||||
mac_list *results = NULL ;
|
||||
int ret = 0 ; // Valeur de retour des fonctions appelées.
|
||||
|
||||
/* Lecture des options de la ligne de commande */
|
||||
read_options(argc, argv, options, capture_iface, &capture_time, file, &direction, &pos_x, &pos_y, &pos_z) ;
|
||||
|
||||
if (options[NUM_OPT_INPUT] == TRUE) // Si l'option INPUT est présente,
|
||||
{
|
||||
if ((ret = read_mac_list_from_file(file, &results)) != 0) // Lecture du fichier.
|
||||
return ret ;
|
||||
print_mac_list(results, options[NUM_OPT_VERB]) ; // Affichage.
|
||||
free_mac_list(&results) ; // Nettoyage
|
||||
return 0 ;
|
||||
}
|
||||
|
||||
printf("Interface de capture : %s\nTemps de capture : %d\n\n", capture_iface, capture_time) ;
|
||||
|
||||
iface_mode_monitor("eth2") ; // Passage de l'interface Wi-Fi en mode Monitor. FIXME ! mettre l'interface Wi-Fi en paramètre du programme (wifi_iface != capture_iface, cf. apd.c).
|
||||
|
||||
|
||||
/**** THREAAAAAAAAAD !!!!!!!! ****/
|
||||
|
||||
|
||||
if ((ret = capture(capture_iface, capture_time, &results, options[NUM_OPT_VERB])) != 0) // Capture de paquets.
|
||||
return ret ; // On quitte avec le code d'erreur si la capture a mal fini.
|
||||
|
||||
print_mac_list(results, options[NUM_OPT_VERB2]) ; // Affichage des paquets capturés.
|
||||
|
||||
if (options[NUM_OPT_OUTPUT] == TRUE) // Si l'option OUTPUT est présente,
|
||||
// ret = write_mac_list_to_file(file, results) ;
|
||||
ret = write_mac_list_to_text_file(file, results, direction, pos_x, pos_y, pos_z) ;
|
||||
|
||||
free_mac_list(&results) ; // Nettoyage
|
||||
|
||||
return ret ;
|
||||
}
|
||||
Loading…
Reference in New Issue