258 lines
8.3 KiB
C
258 lines
8.3 KiB
C
/*
|
|
* This file is part of the rtap localisation project.
|
|
*/
|
|
|
|
#include "../../libowlps/owlps.h"
|
|
|
|
#define DEBUG
|
|
|
|
/* Codes d'erreurs */
|
|
#define ERR_CREATING_SOCKET 1 // Erreur lors de la création de la socket d'envoi
|
|
#define ERR_BAD_USAGE 2 // Mauvais nombre d'arguments lors de l'appel au programme
|
|
#define ERR_SENDING_INFO 3 // Erreur lors de l'envoi de l'une des demandes de positionnement
|
|
|
|
/* Nombre de paquets envoyés */
|
|
#define DEFAULT_NBPKT_CALIB 20 // Rafale de 20 paquets lors de la calibration
|
|
#define DEFAULT_NBPKT_NORMAL 10 // Nombre de paquets envoyés dans le cas d'une demande de localisation
|
|
|
|
/* Délai entre chaque paquet envoyé */
|
|
#define DEFAULT_DELAY_CALIB 50000 // Délai entre chaque émission de paquet lors de la calibration (en microsecondes)
|
|
#define DEFAULT_DELAY_NORMAL 25000 // Délai entre chaque émission de paquet dans le cas d'une demande de localisation (en microsecondes)
|
|
|
|
/* Arguments du programme */
|
|
#define OPTIONS "d:i:t:n:"
|
|
|
|
|
|
/* Affiche le mode d'emploi du programme */
|
|
void print_usage(char *prog)
|
|
{
|
|
printf("Usage :\n\
|
|
\t- Demande de localisation : %s -d destination_ip [-i iface] [-t delay] [-n nb_packets]\n\
|
|
\t- Requête de calibration : %s -d destination_ip [-i iface] [-t delay] [-n nb_packets] direction x y z\n\
|
|
destination_ip est l'adresse IP vers laquelle sera envoyée la demande de localisation.\n\
|
|
delay est le délai d'attente entre chaque paquet émis.\n\
|
|
nb_packets est le nombre de paquets émis pour la demande.\n\
|
|
iface est une chaîne désignant le nom de interface réseau à partir de laquelle envoyer la demande (par exemple \"eth2\"). Si elle n'est pas spécifiée, le choix de l'interface source est automatique. Vous devez être root pour utiliser cette option.\n\
|
|
", prog, prog) ;
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char *argv[])
|
|
{
|
|
struct timeval request_time ;
|
|
char *buf = NULL ; // Paquet à envoyer
|
|
int buf_offset ; // Indice dans le paquet à envoyer, utilisé lors de sa création
|
|
int buf_size ; // Taille du paquet envoyé
|
|
|
|
struct sockaddr_in server, client ;
|
|
int sockfd ; // Descripteur de la socket d'envoi
|
|
ssize_t nsent ; // Retour de sendto
|
|
|
|
int i ; // Compteur
|
|
BOOL is_calibration_request = FALSE ; // Sera positionné à TRUE si le paquet est une requête de calibration (FALSE pour une simple demande de localisation)
|
|
|
|
struct {
|
|
char dest_ip[16] ; // Adresse IP de destination des paquets de la demande
|
|
char iface[IFNAMSIZ + 1] ; // Interface réseau depuis laquelle on envoit les paquets
|
|
long delay ; // Temps d'attente entre chaque émission de paquet
|
|
short nb_pkt ; // Nombre de paquets envoyés pour la demande
|
|
// Données de calibration :
|
|
DIRECTION direction ;
|
|
float x ;
|
|
float y ;
|
|
float z ;
|
|
} options = {"", "", -1, -1, 0, 0, 0, 0} ;
|
|
int opt ; // Retour de getopt
|
|
|
|
// int delay = (argc == ARGC_NORMAL ? DELAY_NORMAL : DELAY_CALIB) ;
|
|
|
|
/* Parcours des arguments de la ligne de commandes */
|
|
while ((opt = getopt(argc, argv, OPTIONS)) != -1)
|
|
{
|
|
switch (opt)
|
|
{
|
|
case 'd' :
|
|
strncpy(options.dest_ip, optarg, 16) ;
|
|
break ;
|
|
case 'i' :
|
|
strncpy(options.iface, optarg, IFNAMSIZ + 1) ;
|
|
break ;
|
|
case 't' :
|
|
options.delay = strtol(optarg, NULL, 0) ;
|
|
break ;
|
|
case 'n' :
|
|
options.nb_pkt = strtol(optarg, NULL, 0) ;
|
|
break ;
|
|
default :
|
|
print_usage(argv[0]) ;
|
|
return ERR_BAD_USAGE ;
|
|
}
|
|
}
|
|
|
|
if (options.dest_ip[0] == '\0') // On vérifie si on a bien une adresse de destination
|
|
{
|
|
fprintf(stderr, "Erreur ! Vous devez spécifier une adresse de destination (-d).\n") ;
|
|
print_usage(argv[0]) ;
|
|
return ERR_BAD_USAGE ;
|
|
}
|
|
|
|
/* Parcours des arguments restants (éventuelles données de calibration) */
|
|
if (argc - optind != 0)
|
|
{
|
|
if (argc - optind == 4)
|
|
{
|
|
is_calibration_request = TRUE ;
|
|
options.direction = strtol(argv[optind++], NULL, 0) ;
|
|
options.x = strtod(argv[optind++], NULL) ;
|
|
options.y = strtod(argv[optind++], NULL) ;
|
|
options.z = strtod(argv[optind], NULL) ;
|
|
}
|
|
else
|
|
{ // Si le nombre d'arguments est mauvais, on quitte
|
|
print_usage(argv[0]) ;
|
|
return ERR_BAD_USAGE ;
|
|
}
|
|
}
|
|
|
|
/* Vérifications des arguments et initialisation des données non initialisées */
|
|
if (options.delay < 0) // Délai non spécifié ou mauvais, application des valeurs par défaut
|
|
{
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "Attention ! delay : application de la valeur par défaut.\n") ;
|
|
#endif // DEBUG
|
|
if (is_calibration_request)
|
|
options.delay = DEFAULT_DELAY_CALIB ;
|
|
else
|
|
options.delay = DEFAULT_DELAY_NORMAL ;
|
|
}
|
|
if (options.nb_pkt < 1) // Nombre de paquets non spécifié ou mauvais, application des valeurs par défaut
|
|
{
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "Attention ! nb_pkt : application de la valeur par défaut.\n") ;
|
|
#endif // DEBUG
|
|
if (is_calibration_request)
|
|
options.nb_pkt = DEFAULT_NBPKT_CALIB ;
|
|
else
|
|
options.nb_pkt = DEFAULT_NBPKT_NORMAL ;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
fprintf(stderr, "Options :\n\
|
|
\tDestination : %s\n\
|
|
\tInterface : %s\n\
|
|
\tDelay : %ld\n\
|
|
\tNumber of packets : %d\n\
|
|
\tDirection : %d\n\
|
|
\tX : %f\n\
|
|
\tY : %f\n\
|
|
\tZ : %f\n",
|
|
options.dest_ip,
|
|
options.iface,
|
|
options.delay,
|
|
options.nb_pkt,
|
|
options.direction,
|
|
options.x,
|
|
options.y,
|
|
options.z
|
|
) ;
|
|
#endif // DEBUG
|
|
|
|
/* Ouverture de la socket UDP vers le serveur d'aggrégation */
|
|
sockfd = create_udp_sending_socket(options.dest_ip, LOC_REQUEST_DEFAULT_PORT, &server, &client) ;
|
|
if (sockfd < 0)
|
|
{
|
|
perror("Erreur ! Impossible de créer la socket vers le serveur d'aggrégation \n");
|
|
return ERR_CREATING_SOCKET ;
|
|
}
|
|
|
|
if (options.iface[0] != '\0') // Si on a spécifié un nom d'interface
|
|
{
|
|
if (setsockopt(sockfd, SOL_SOCKET, SO_BINDTODEVICE, options.iface, strlen(options.iface) + 1) == -1)
|
|
{
|
|
fprintf(stderr, "Erreur ! Impossible de sélectionner l'interface %s pour l'envoi du paquet : ", options.iface) ;
|
|
perror("") ;
|
|
fprintf(stderr, "Envoi sur l'interface par défaut.\n") ;
|
|
}
|
|
}
|
|
|
|
|
|
/* Création du paquet à envoyer */
|
|
gettimeofday(&request_time, NULL) ;
|
|
|
|
if (is_calibration_request) // Paquet calibration
|
|
{
|
|
printf("Envoi Calibration effectué à : %llu\n", timeval_to_ms(request_time)) ;
|
|
|
|
buf_offset = 0 ;
|
|
buf_size = sizeof(char) * 2 + sizeof(struct timeval) + sizeof(float) * 3 ;
|
|
buf = malloc(buf_size) ;
|
|
|
|
buf[buf_offset++] = PACKET_TYPE_CALIBRATION ; // Type de paquet = calibration
|
|
memcpy(&buf[buf_offset], &request_time, sizeof(request_time)) ;
|
|
buf_offset += sizeof(request_time) ;
|
|
buf[buf_offset++] = options.direction ; // Direction
|
|
/*
|
|
float posX = options.x ;
|
|
float posY = options.y ;
|
|
float posZ = options.z ;
|
|
*/
|
|
#ifdef DEBUG
|
|
printf("Direction = %d, X = %f, Y = %f, Z = %f\n", buf[buf_offset - 1], options.x, options.y, options.z) ;
|
|
#endif // DEBUG
|
|
memcpy(&buf[buf_offset], &options.x, sizeof(float)) ;
|
|
buf_offset += sizeof(float) ;
|
|
memcpy(&buf[buf_offset], &options.y, sizeof(float)) ;
|
|
buf_offset += sizeof(float) ;
|
|
memcpy(&buf[buf_offset], &options.z, sizeof(float)) ;
|
|
}
|
|
|
|
else // Paquet normal
|
|
{
|
|
printf("Envoi normal effectué à : %llu\n", timeval_to_ms(request_time)) ;
|
|
buf_size = sizeof(char) + sizeof(struct timeval) ;
|
|
buf = malloc(buf_size) ;
|
|
buf[0] = PACKET_TYPE_NORMAL ; // Type de paquet = demande
|
|
memcpy(&buf[1], &request_time, sizeof(request_time)) ;
|
|
}
|
|
|
|
|
|
/* Envoi des infos au serveur d'aggrégation */
|
|
nsent = sendto(sockfd, (void *) buf, buf_size, 0, (struct sockaddr *) &server, (socklen_t) sizeof(server)) ; // Envoi d'un paquet.
|
|
if (nsent != (ssize_t) buf_size)
|
|
{
|
|
perror("Erreur lors de l'envoi des informations au serveur ") ;
|
|
return ERR_SENDING_INFO ;
|
|
}
|
|
#ifdef DEBUG
|
|
printf("Paquets envoyés : .") ;
|
|
fflush(stdout) ;
|
|
#endif // DEBUG
|
|
|
|
for (i = 0 ; i < options.nb_pkt - 1 ; i++) // Si tels sont les paramètres, on envoit éventuellement la suite de la rafale de paquets :
|
|
{
|
|
usleep(options.delay) ; // On attend le temps voulu entre chaque paquet.
|
|
|
|
nsent = sendto(sockfd, (void *) buf, buf_size, 0, (struct sockaddr *) &server, (socklen_t) sizeof(server)) ;
|
|
if (nsent != (ssize_t) buf_size)
|
|
{
|
|
perror("Erreur lors de l'envoi des infos au serveur ") ;
|
|
return ERR_SENDING_INFO ;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
putchar('.') ;
|
|
fflush(stdout) ;
|
|
#endif // DEBUG
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
putchar('\n') ;
|
|
#endif // DEBUG
|
|
|
|
|
|
(void) close(sockfd) ;
|
|
|
|
return 0 ;
|
|
}
|