View source for Mini-ping

From Livre IPv6

You do not have permission to edit this page, for the following reason:
The action you have requested is limited to users in one of the groups: Users, Administrators.
You can view and copy the source of this page:
{{suivi| Exemple de client/serveur TCP | Exemple de client/serveur TCP | Utilisation du multicast | Utilisation du multicast }}
==Description==

La commande proposée est une version très simplifiée de <tt>ping6</tt>. Néanmoins, cela permettra de comprendre l'essentiel du fonctionnement de cette commande. Son principe est le suivant, on émet un paquet ICMPv6 du type ECHO_REQUEST et on active une temporisation. Si, le délai étant expiré, on n'a pas reçu de paquet ICMPv6 de type ECHO_REPLY en provenance de la machine cible, on imprime un message d'erreur. Dans le cas contraire, on imprime le nom de la machine émettrice de l'ECHO_REPLY. Par exemple, si le nom donné à cette commande est one_ping6 :

 $ '''one_ping6 peirce'''
 Sending ECHO REQUEST to: peirce.ipv6.logique.jussieu.fr
 Waiting for answer (timeout = 5s)...
 Got answer from 2001:660:101:201:200:f8ff:fe31:1942 (seq = 0)
 $

Remarque : ICMP étant un protocole non fiable, il peut arriver qu'un premier paquet soit perdu, par exemple à cause du temps passé à exécuter le protocole de "recherche de voisins". Il suffit en général de relancer la commande pour que la réponse apparaisse la seconde fois.

one_ping6 accepte les options suivantes :

* <tt>-d données</tt>. Ces données seront incluses dans le paquet ECHO_REQUEST.
* <tt>-s numéro de séquence</tt>. La valeur défaut est zéro.
* <tt>-t durée de la temporisation</tt>. La valeur par défaut est fixée lors de la compilation via la macro-définition TIMEOUT.

Par exemple,

 $ '''one_ping6 -d 'Un petit essai' -s 12 -t 3 peirce'''
 Sending ECHO REQUEST to: peirce.ipv6.logique.jussieu.fr
 Waiting for answer (timeout = 3s)...
 Got answer from 2001:660:101:201:200:f8ff:fe31:1942 (seq = 12)
 with data [
 Un petit essai
 ] (end of data)
 $

Les sources de ce programme se composent de trois fichiers : le programme principal, le source de la fonction assurant l'émission du paquet ECHO_REQUEST et le source de la fonction ayant en charge la gestion de la temporisation et la réception du paquet ECHO_REPLY.

==Envoi du paquet ECHO_REQUEST==

Rappelons tout d'abord que le nouveau protocole ICMPv6 est une refonte presque complète d'ICMP (sur IPv4). Néanmoins, le format des paquets ECHO_REQUEST et ECHO_REPLY est inchangé excepté la valeur du champ type (cf. figure format d'un message ICMPv6 demande et réponse d'écho).

[[image:CS43.gif]]

La préparation d'un paquet ECHO_REQUEST est similaire en ICMP(v4) ou ICMPv6. La seule différence est que le calcul du checksum n'est maintenant plus à la charge du programmeur mais effectué par le noyau. Plus précisément, ainsi qu'il est spécifié dans l'API "avancée", pour toutes les sockets de type <tt>SOCK_RAW</tt> et de protocole <tt>IPPROTO_ICMPV6</tt>, c'est le noyau qui doit calculer le checksum des paquets ICMPv6 sortants (dans le cas des Linux anciens, il faut activer le calcul du checksum, comme on le voit en lignes 81 à 95 du fichier [[#progprinc|ping.c]] ).

Le paquet ICMPv6 de type ECHO_REQUEST, étant ainsi constitué, on l'expédie, via la primitive sendto à la machine cible.
 
	
  1| #include <stdio.h>
  2| #include <string.h>
  3| #include <sys/types.h>
  4| #include <sys/socket.h>
  5| #include <netinet/in.h>
  6| #include <netinet/ip6.h>
  7| #include <netinet/icmp6.h>
  8| #include <arpa/inet.h>
  9| #include <netdb.h>
 10|  
 11| #ifndef MAX_DATALEN
 12| #define MAX_DATALEN (1280 - sizeof(struct ip6_hdr) - sizeof(struct icmp6_hdr))
 13| #endif
 14|  
 15| static u_char buf[sizeof(struct icmp6_hdr) + MAX_DATALEN]; 
 16| 
 17| int send_echo_request6(int sock, struct sockaddr_in6 *dst, uint16_t id,
 18|                        uint16_t seq, char *opt_data, int opt_data_size)
 19| {
 20| int noc, icmp_pkt_size = sizeof(struct icmp6_hdr);
 21| struct icmp6_hdr *icmp;   
 22| 
 23|    if (opt_data && opt_data_size > MAX_DATALEN) {
 24|       fprintf(stderr, "send_echo_request6: too much data (%d > %d)\n",
 25|       opt_data_size, MAX_DATALEN);
 26|       return -1;
 27|    }
 28| 
 29|    memset((void *) buf, 0, sizeof(buf));
 30|    icmp = (struct icmp6_hdr *) buf;
 31|    icmp->icmp6_type = ICMP6_ECHO_REQUEST;
 32|    icmp->icmp6_id = id;
 33|    icmp->icmp6_seq = seq;
 34|    if (opt_data) {
 35|       memcpy(buf + sizeof(struct icmp6_hdr), opt_data, opt_data_size);
 36|       icmp_pkt_size += opt_data_size;
 37|    } 
 39|    noc = sendto(sock, (char *) icmp, icmp_pkt_size, 0,
 39|                 (struct sockaddr *) dst, sizeof(struct sockaddr_in6));
 40|    if (noc < 0) {
 41|       perror("send_echo_request6: sendto");
 42|       return -1;
 43|    }
 44|    if (noc != icmp_pkt_size) {
 45|       fprintf(stderr, "send_echo_request6: wrote %d bytes, ret=%d\n",
 46|               icmp_pkt_size, noc);
 47|       return -1;
 48|    }
 49|    return 0;
 50| }

Une dernière remarque avant de clore cette section. On a vu que l'on pouvait inclure des données dans le paquet ICMPv6 émis. La taille maximale de celles-ci a été choisie (ligne 12) pour que les paquets ne soient jamais fragmentés (le protocole IPv6 exigeant une taille de paquet minimale de 1280 octets, en-têtes comprises). Une taille plus grande serait possible, les paquets ICMP ECHO pouvant parfaitement être fragmentés.

==La réception du paquet ECHO_REPLY==

C'est la fonction wait_for_echo_reply6 qui gère la réception du paquet ECHO_REPLY. Cette fonction tout d'abord (lignes 32 à 35) utilise le mécanisme de filtrage des paquets ICMPv6, mécanisme défini dans l'API "étendue", afin que seuls les paquets ICMPv6 de type ECHO_REPLY soient reçus sur la socket d'écoute.

On trouve ensuite une boucle sans fin dont on sort soit sur réception du signal SIGALRM (armé juste avant l'entrée de la boucle à la ligne 36), c'est-à-dire lorsque le délai de temporisation (argument timeout) est expiré, soit lorsque la fonction <tt>recv_icmp_pkt</tt>, qui analyse tous les paquets ICMPv6 de type ECHO_REPLY reçus sur la socket d'écoute (argument sock) par l'émetteur, retourne 0, c'est-à-dire lorsque le paquet ECHO_REPLY en provenance de la machine cible a été détecté.
 
	
   1| #include <stdio.h>
   2| #include <unistd.h>
   3| #include <string.h>
   4| #include <sys/types.h>
   5| #include <sys/socket.h>
   6| #include <netinet/in.h>
   7| #include <netinet/ip6.h>
   8| #include <netinet/icmp6.h>
   9| #include <arpa/inet.h>
  10| #include <errno.h>
  11| #include <signal.h>
  12| #include <setjmp.h>
  13|  
  14| #ifndef MAX_DATALEN
  15| #define MAX_DATALEN (1280 - sizeof(struct ip6_hdr) - sizeof(struct icmp6_hdr))
  16| #endif
  17|  
  18| static void on_timeout(int);
  19| static int recv_icmp_pkt(int, struct sockaddr_in6 *, uint16_t, uint16_t);
  20|  
  21| static u_char buf[sizeof(struct icmp6_hdr) + MAX_DATALEN];
  22| static jmp_buf j_buf;
  23|  
  24| void wait_for_echo_reply6(int sock, struct sockaddr_in6 *from, uint16_t id,
  25|                           uint16_t seq, int timeout)
  26| {
  27| struct icmp6_filter filter;
  28| char from_ascii[INET6_ADDRSTRLEN];
  29|  
  30|    inet_ntop(AF_INET6, &from->sin6_addr, from_ascii, INET6_ADDRSTRLEN);
  31|  
  32|    ICMP6_FILTER_SETBLOCKALL(&filter);
  33|    ICMP6_FILTER_SETPASS(ICMP6_ECHO_REPLY, &filter);
  34|    setsockopt(sock, IPPROTO_ICMPV6, ICMP6_FILTER, (const void *) &filter,
  35|               sizeof(filter));
  36|    signal(SIGALRM, on_timeout);
  37|    alarm(timeout);
  38|    for (;;) {
  39|       int noc, from_len = sizeof(struct sockaddr_in6);
  40|  
  41|       if (setjmp(j_buf) == SIGALRM) {
  42|          fprintf(stderr, "No answer from %s\n", from_ascii);
  43|          break;
  44|       }
  45|       noc = recvfrom(sock, buf, sizeof(buf), 0,
  46|                      (struct sockaddr *) from, &from_len);
  47|       if (noc < 0) {
  48|          if (errno == EINTR)
  49|             continue;
  50|          perror("wait_for_echo_reply6: recvfrom");
  51|          continue;
  52|       }
  53|       if (recv_icmp_pkt(noc, from, id, seq) == 0)
  54|          break;
  55|    }
  56|    alarm(0);
  57|    signal(SIGALRM, SIG_DFL);
  58|    return;
  59| }
  60|  
  61| static void on_timeout(int sig)
  62| {
  63|    longjmp(j_buf, sig);
  64| } 

Contrairement à ce qui se passait en IPv4, l'entête IPv6 n'est pas incluse lors de la réception d'un paquet ICMPv6 (sauf si l'option I<tt>P_HDRINCL</tt> est positionnée). Ainsi dans la fonction <tt>recv_icmp_pkt</tt>, on commence directement par tester le champ identificateur et le numéro de séquence (lignes 84 et 85). Si ce test a été passé avec succès, c'est-à-dire que l'on a bien reçu le paquet attendu, la fonction <tt>recv_icmp_pkt</tt> retourne <tt>0</tt> après avoir, s'il y en a, imprimé les données incluses dans le paquet. Dans le cas contraire, la valeur retournée est 1.
 
	
  65| static int recv_icmp_pkt(int noc, struct sockaddr_in6 *from, uint16_t id,
  66|                          uint16_t seq)
  67| {
  68| int opt_data_size;
  69| char from_ascii[INET6_ADDRSTRLEN];
  70| struct icmp6_hdr *icmp;
  71|  
  72|    if (inet_ntop(AF_INET6, &from->sin6_addr, from_ascii,
  73|                  INET6_ADDRSTRLEN) == NULL) {
  74|       perror("inet_ntop");
  75|       return -1;
  76|    }
  77|    if (noc < sizeof(struct icmp6_hdr)) {
  78|       fprintf(stderr, "recv_icmp_pkt: packet too short from %s\n",
  79|               from_ascii);
  80|       return -1;
  81|    }
  82|    opt_data_size = noc - sizeof(struct icmp6_hdr);
  83|    icmp = (struct icmp6_hdr *) buf;
  84|    if (icmp->icmp6_id != id || icmp->icmp6_seq != seq)
  85|       return 1;
  86|    fprintf(stdout, "Got answer from %s (seq = %d)\n", from_ascii, seq);
  87|    if (opt_data_size > 0) {
  88|       fprintf(stdout, "with data [\n");
  89|       fflush(stdout);
  90|       if (opt_data_size > MAX_DATALEN) {
  91|          fprintf(stderr,
  92|                  "recv_icmp_pkt: received too much data from %s\n",
  93|                  from_ascii);
  94|       }
  95|       else
  96|          write(1, (char *) icmp + sizeof(struct icmp6_hdr), opt_data_size);
  97|       fprintf(stdout, "\n] (end of data)\n");
  98|    }
  99|    return 0;
 100| }

==<div id="progprinc">Programme principal</div>==

Le programme principal ne présente pas de difficulté particulière puisqu'il est une application directe des fonctions décrites dans les deux sections précédentes.

La première partie est triviale : elle concerne le traitement des (éventuelles) options.
 
	
   1| #include <stdio.h>
   2| #include <stdlib.h>
   3| #include <unistd.h>
   4| #include <string.h>
   5| #include <sys/socket.h>
   6| #include <netinet/in.h>
   7| #include <netinet/icmp6.h>
   8| #include <arpa/inet.h>
   9| #include <netdb.h>
  10| #ifdef __linux__
  11| #include <linux/version.h>
  12| #if LINUX_VERSION_CODE < KERNEL_VERSION(2,4,19)
  13| #define LINUX_CKSUM_CALCUL_EXPLICITE
  14| #endif
  15| #endif
  16|  
  17| #ifndef TIMEOUT
  18| #define TIMEOUT 5
  19| #endif
  20|  
  21| extern int send_echo_request6(int, struct sockaddr_in6 *, uint16_t,
  22|                               uint16_t, char *, int);
  23| extern void wait_for_echo_reply6(int, struct sockaddr_in6 *, uint16_t,
  24|                                  uint16_t, int);
  25|  
  26| static void usage(char *);
  27|  
  28| int main(int argc, char **argv)
  29| {
  30| int sock, timeout = TIMEOUT, a, ecode;
  31| char *opt_data = NULL, *dst_ascii;
  32| int opt_data_size = 0;
  33| uint16_t id, seq = 0;
  34| struct sockaddr_in6 *dst;
  35| struct addrinfo *res;
  36| struct addrinfo hints = {
  37|                          AI_CANONNAME,
  38|                          PF_INET6,
  39|                          SOCK_RAW,
  40|                          IPPROTO_ICMPV6,
  41|                          0,
  42|                          NULL,
  43|                          NULL,
  44|                          NULL
  45|                         };
  46|  
  47|    while((a = getopt(argc, argv, "d:s:t:")) != EOF)
  48|       switch(a) {
  49|       case 'd':
  50|          opt_data = optarg;
  51|          opt_data_size = strlen(optarg) + 1;
  52|          break;
  53|       case 's':
  54|          seq = (uint16_t) atoi(optarg);
  55|          break;
  56|       case 't':
  57|          timeout = atoi(optarg);
  58|          break;
  59|       default:
  60|          usage(*argv);
  61|       }
  62|       argc -= optind;
  63|       if (argc != 1)
  64|          usage(*argv);
  65|       argv += optind; 

Ensuite c'est la préparation de l'adresse de la socket distante, opération qui est devenue maintenant familière. Noter que l'on a affecté au champ <tt>ai_family</tt> de la structure <tt>hints</tt> la valeur <tt>PF_INET6</tt> lors de sa déclaration (ligne 38) : on doit s'assurer que la machine cible est une machine IPv6 (il n'existe pas de mode double pile avec utilisation d'[[Autres types d'adresses#mappee|adresse IPv4 mappé]] pour le protocole ICMP, car celui-ci a fortement changé entre IPv4 et IPv6). On s'est interdit des adresses destination de type multicast (lignes 73 à 76) car, comme l'on ne traite qu'un paquet en réception, cela n'aurait guère d'intérêt.

On crée la socket qui servira à l'émission du paquet ECHO_REQUEST et à la réception du paquet ECHO_REPLY en provenance de la machine cible.

À la ligne 96, la valeur du champ identificateur du paquet ICMPv6 est calculée en fonction du numéro de processus en prenant les 16 premiers bits. C'est une technique sûre (et simple) quant à la garantie de l'unicité de l'identificateur. Enfin le paquet ECHO_REQUEST est émis (<tt>send_echo_request6</tt>) puis on attend la réponse éventuelle (<tt>wait_for_echo_reply6</tt>).
 
	
  66|       ecode = getaddrinfo(*argv, NULL, &hints, &res);
  67|       if (ecode) {
  68|          fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(ecode));
  69|          exit(1);
  70|       }
  71|       dst_ascii = res->ai_canonname ? res->ai_canonname : *argv;
  72|       dst = (struct sockaddr_in6 *) res->ai_addr;
  73|       if (IN6_IS_ADDR_MULTICAST(&dst->sin6_addr)) {
  74|          fprintf(stderr, "%s multicast address not supported\n", dst_ascii);
  75|          exit(1);
  76|       }
  77|       if ((sock = socket(res->ai_family, res->ai_socktype, res->ai_protocol)) < 0) {
  78|          perror("socket (RAW)");
  79|          exit(1);
  80|       }
  81| #ifdef LINUX_CKSUM_CALCUL_EXPLICITE
  82|       {
  83|       /*
  84|        * Pour linux avant 2.4.19, il faut demander le calcul des checksums
  85|        * sur les sockets raw, meme pour des paquets icmpv6
  86|        */
  87| #define OFFSETOF(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
  88|        int off = OFFSETOF(struct icmp6_hdr, icmp6_cksum);
  89|  
  90|           if (setsockopt(sock, SOL_RAW, IPV6_CHECKSUM, &off, sizeof off) < 0) {
  91|              perror("setsockopt (IPV6_CHECKSUM)");
  92|              exit(1);
  93|           }
  94|      }
  95| #endif
  96|      id = (uint16_t) (getpid() & 0xffff);
  97|      fprintf(stdout, "Sending ECHO REQUEST to: %s\n", dst_ascii);
  98|      if (send_echo_request6(sock, dst, id, seq, opt_data,
  99|                             opt_data_size) < 0)
 100|         exit(1);
 101|      fprintf(stdout, "Waiting for answer (timeout = %ds)...\n", timeout);
 102|      wait_for_echo_reply6(sock, dst, id, seq, timeout);
 103|      close(sock);
 104|      exit(0);
 105| }
 106|  
 107| static void usage(char *s)
 108| {
 109|    fprintf(stderr, "Usage: %s [-d data] [-s seq] [-t timeout] host | addr\n", s);
 110|    exit(1);
 111| }
{{suivi| Exemple de client/serveur TCP | Exemple de client/serveur TCP | Utilisation du multicast | Utilisation du multicast }}
Template used on this page:
Template:Suivi (view source)
Return to Mini-ping.
Retrieved from "http://livre.g6.asso.fr/index.php/Mini-ping"
Association G6

View source for Mini-ping

From Livre IPv6

Views

Personal tools

Navigation

Search

Tools
