1 – Définition de l’exécutable

L’utilitaire Ping permet, à la base, de tester la présence d’un hôte distant ainsi que son temps de réponse. L’intérêt de TcpPing est d’émettre un datagramme en TCP SYN et mesurer ainsi le temps de réponse de l’hôte distant. Si le port de destination est écouté, alors l’utilitaire recevra un SYN/ACK. Par contre, si le port distant est fermé, alors l’utilitaire recevra un RST/ACK.

C’est intéressant dans le cas où un hôte distant ne répond pas au PingIcmp ou qu’un Firewall bloque les paquets ICMP. Alors, vous allez « pinguer » directement le port 80 d’un serveur WEB, le port 25 d’un serveur de messagerie ou tous autres ports.

2 – Screen shot

3 – Download

Nom : TcpPing.exe
Mode : Console
Version : 2.4
Librairie : 3.12
Taille : 92 Ko
Auteur : sebastien.fontaine@FrameIP.com.pas.de.spam
Date de création : 02 Août 2004
Dernière compilation : 29 Juin 2008

4 – Suivi du développement

4.1 – Problème restant

4.2 – RoadMap

4.3 – Suivi du projet

• V2.4.3.12
  Ajout de l’argument ip_gateway afin de pouvoir spécifier l’adresse IP de son routeur.
  Passage de la taille par défaut de la data à 0.
• V2.3.3.11
  Réécriture de la fonction de réception des trames pour la passer en mode Pcap.
  Suppression de la pause dans le cas d’un seul envoi.
• V2.2.3.10
  Problème trouvé par decize comme quoi même si on spécifie -ip_destination x.x.x.x, la requête ARP cherche à résoudre 192.168.101.254. Correction du soucis en ajoutant strcpy(ip_destination,convertion_ip(entete_ipv4.ip_destination)); dans la gestion de l’argument -ip_destination.
  Remplacement de strcmp(strlwr( par stricmp( dans la gestion des arguments
• V2.1.3.10
  Suppression de la fonction WSAIoctl();
• V2.0.3.10
  Compilation en Libpcap afin de générer les trames au niveau 2
  Ajout de la prise en compte de la réception d’un RST/ACK
• V1.0.3.8
  Début du développement afin de créer un ping basé sur l’envoi d’un Syn.
  Copie du projet Synflood comme base de modèle
  Intégration de la réception basé sur l’écoute en mode Raw grâce à la commande WSAIoctl appuyé de la valeur SIO_RCVALL.

5 – Code source

5.1 – TcpPing.cpp

// ********************************************
// Nom : TcpPing.cpp
// Auteur : sebastien.fontaine@frameIP.com.pas.de.spam
// Date de création : 02 août 2004
// version : 2.2.3.10
// Licence : Cette executable est libre de toute utilisation.
//           La seule condition existante est de faire référence
//           au site http://www.frameip.com afin de respecter le travail d'autrui.
// ********************************************

// ********************************************************
// Les includes
// ********************************************************
// Il faut ajouter dans les proprités du projet => C++ => Command Line :
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Include"
// /I "C:\RepPerso\Personnel\Developpement\Projets\LibrairieSocket"
#include "LibrairieSocket.h"
#include "pcap.h"

// ********************************************************
// Les Librairies
// ********************************************************
// Il faut ajouter dans les proprités du projet => Linker => Command Line :
// /NODEFAULTLIB:libcd.lib
// /LIBPATH:"C:\RepPerso\Personnel\Developpement\Projets\LibrairiePcap\Lib"
// /NODEFAULTLIB:LIBCMTD.lib
#pragma comment(lib,"Packet.lib")
#pragma comment(lib,"wpcap.lib")

// ********************************************************
// Les procédures
// ********************************************************
void initiation_des_variables(void);
void gestion_des_arguments(int argc, char* argv[]);
void Changement_aleatoire_des_valeurs(void);
void initiation_des_variables_automatiques(void);
void envoi_de_la_trame_winsock(void);
void envoi_de_la_trame_pcap(void);
void reception_de_la_trame(void);

// ********************************************************
// Les variables
// ********************************************************
struct mac entete_mac;                                    // Entête Ethernet
struct ipv4 entete_ipv4;                                   // Entete IP
struct ipv4 *entete_ipv4_reception;      // Entete IP receptionnée
struct tcp entete_tcp;                                       // Entete TCP
struct tcp *entete_tcp_reception;         // Entete TCP receptionnée
char data_a_envoyer[65535];                         // Data
unsigned int longueur_de_data_a_envoyer;      // Longueur du char *, je n'utilise pas strlen car il peux y avoir des 0
unsigned char trame_a_envoyer[65535];                     // Entete IP + data
int nombre_de_caractere_emis;                       // Variable récupérant le nombre de caractères émis
unsigned long loops;                                                    // Compteur permettant de lancer x fois les trames
char ip_source[16];                 // Adresse IP Source permettant d'initier entete_ipv4.ip_source
char ip_destination[16];           // Adresse IP Destination permettant d'initier entete_ipv4.ip_destination
bool bouclage_infinie;                                      // Variable permettant de définir le mode de boucle infinie (quand loops=0)
bool ip_source_aleatoire;                                // Acive ou désactive le mode IP Source Aléatoire
bool port_source_aleatoire;                             // Acive ou désactive le mode Port Source Aléatoire
unsigned int pause_entre_chaque_frame;
unsigned int timeout;                                        // Temps d'attente maximum en cas de non réponse
unsigned int choix_mode_d_envoi;                                                      // Variable définissant le mode d'envoi (0=Soket - 1=Libpcap)
unsigned char numero_de_l_interface;                                     // Numéro de l'interface qui sera utilisée
struct gestion_des_interfaces liste_des_interfaces; // structure possédant les informations des intefaces
struct adresse_mac adresse_mac_tampon;                                          // Adresse MAC
bool mac_destination_auto;                                                                            // Variable permettant de savoir si l'adresse MAC de destination doit être résolu en ARP
bool mac_source_auto;                                                                                              // Variable permettant de savoir si l'adresse MAC source doit être prise à partir de l'interface
LARGE_INTEGER cpu_frequence;
LARGE_INTEGER temps_de_reponse1;
LARGE_INTEGER temps_de_reponse2;

int main (int argc, char* argv[])
            {
            initiation_des_variables();
            gestion_des_arguments(argc,argv);
            initiation_des_variables_automatiques();
            printf("\n");
            while ( (loops!=0)||(bouclage_infinie==TRUE) )
                        {
                        loops--;
                        Changement_aleatoire_des_valeurs();

                        // ********************************************************
                        // Envoi de la trame
                        // ********************************************************
                        if (choix_mode_d_envoi==0)
                                   envoi_de_la_trame_winsock();
                        else
                                   envoi_de_la_trame_pcap();

                        // ********************************************************
                        // Reception de la trame
                        // ********************************************************
                        reception_de_la_trame();

                        Sleep(pause_entre_chaque_frame);
                        }
            printf("\n");
            return(1);
            }

void initiation_des_variables(void)
            {
            structure_ip_local reception_des_ip_locales;

            // ********************************************************
            // Affichage de la banniere
            // ********************************************************
            printf("\nTcpPing -  Send SYN TCP and display the answer time - Version 2.2.3.10");
            printf("\nCreate on August 02, 2004, Last compilation on October 28, 2006");
            printf("\nCreated by Sebastien FONTAINE - http://www.frameip.com");
            printf("\nYour firewall must not be activated");
            printf("\n");

            // ********************************************************
            // Initiation diverse
            // ********************************************************
            srand(GetTickCount());                                   // Initialise le Random
            QueryPerformanceFrequency((LARGE_INTEGER *)&cpu_frequence); // Initialisation de la fréquence pour le compteur
            pause_entre_chaque_frame=1000;
            timeout=2;
            choix_mode_d_envoi=1;
            numero_de_l_interface=0;
            liste_des_interfaces=recuperation_des_interfaces();
                        
            // ********************************************************
            // Initiation des arguments
            // ********************************************************
            port_source_aleatoire=true;
            ip_source_aleatoire=false;
            loops=1;
            bouclage_infinie=false;

            // ********************************************************
            // Options de la couche DATA
            // ********************************************************
            strcpy(data_a_envoyer,"www.frameip.com");
            longueur_de_data_a_envoyer=(unsigned int)strlen(data_a_envoyer);

            // ********************************************************
            // Options de l'entête MAC
            // ********************************************************
            mac_source_auto=true;
            mac_destination_auto=true;
            entete_mac.type=htons(2048); // 08 00 indiquant un datagramme IP

            // ********************************************************
            // Initialisation de l'entete Ip
            // ********************************************************
            entete_ipv4.ihl=5;
            entete_ipv4.version=4;
            entete_ipv4.tos=0;
            entete_ipv4.length=0;
            entete_ipv4.id=0;                                                        // Il est initialisé plutard
            entete_ipv4.offset=0;
            entete_ipv4.ttl=100;
            entete_ipv4.type=6;
            reception_des_ip_locales=recuperation_ip_local(false);
            strcpy(ip_source,reception_des_ip_locales.adresse_ip_local[0]);
            entete_ipv4.ip_source=resolution_de_nom(false,ip_source);
            strcpy(ip_destination,"192.168.101.254");
            entete_ipv4.ip_destination=resolution_de_nom(FALSE,ip_destination);

            // ********************************************************
            // Initialisation de l'entete TCP
            // ********************************************************
            entete_tcp.port_source=0;                              // Il est initialisé plutard
            entete_tcp.port_destination=htons(23);
            entete_tcp.sequence=0;                                              // Il est initialisé plutard
            entete_tcp.accuse=0;
            entete_tcp.reserved=0;
            entete_tcp.offset=5; // taille de l'entête Tcp
            entete_tcp.flag_fin=0;
            entete_tcp.flag_syn=1;
            entete_tcp.flag_rst=0;
            entete_tcp.flag_psh=0;
            entete_tcp.flag_ack=0;
            entete_tcp.flag_urg=0;
            entete_tcp.reserved2=0;
            entete_tcp.window=htons(16384);                  // Valeur relevée dans un Netmon après un "Telnet IP port"
            entete_tcp.checksum=0;
            entete_tcp.pointeur=0;
            }

void gestion_des_arguments(int argc,char* argv[])
            {
            char *caractere_non_convertit;
            unsigned int i;

            // ********************************************************
            // Affichage de l'aide
            // ********************************************************
            if ( (argc>1) && (strcmp(argv[1],"-?")==0) || (argc==1) )
                        {
                        printf("\n");
                        printf("\n\nGENERAL OPTIONS");
                        printf("\n-?                    This help");
                        printf("\n-send_mode            0=Soket 1=Libpcap  Default: %d",choix_mode_d_envoi);
                        printf("\n-loops                Number of loops    Default: %d (0 => no stop)",loops);
                        printf("\n-wait                 Wait after frame   Default: %d ms",pause_entre_chaque_frame);
                        printf("\n-timeout              Maximum wait       Default: %d s",timeout);

                        printf("\n\nFREE INTERFACES");
                        for(i=0;i<(signed)liste_des_interfaces.nombre;i++)
                                   printf("\n%d - %s",i,liste_des_interfaces.description[i]);
                        printf("\n-interface            Interface choice   Default: %d",numero_de_l_interface);

                        printf("\n\nIP HEADER OPTIONS (-mac_type 2048)");
                        printf("\n-ip_source            @Ip or host name   Default: %s (0 => random)",ip_source);
                        printf("\n-ip_destination       @Ip or host name   Default: %s (0 => random)",ip_destination);

                        printf("\n\nTCP HEADER OPTIONS (-ip_type 6)");
                        printf("\n-tcp_port_source      Between 0 & 65535  Default: %d (0 => random)",htons(entete_tcp.port_source));
                        printf("\n-tcp_port_destination Between 0 & 65535  Default: %d (0 => random)",htons(entete_tcp.port_destination));

                        printf("\n\nOPTIONS OF THE DATA LAYER");
                        printf("\n-data_size            data size          Default: %d",longueur_de_data_a_envoyer);
                        printf("\n");
                        printf("\nsample :\ntcpping -interface 2 -ip_destination smtp.laposte.net -tcp_port_destination 25");
                        printf("\n\n");
                        exit(0);
                        }

            // ********************************************************
            // Récupération des arguments
            // ********************************************************
            for (i=1;i<(unsigned int)argc;i=i+1)
                        {
                        // ********************************************************
                        // Options Générales
                        // ********************************************************
                        if (stricmp(argv[i],"-send_mode")==0)
                                   {
                                   choix_mode_d_envoi=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);
                                   if (choix_mode_d_envoi!=1)
                                               choix_mode_d_envoi=0;
                                   }
                        if ( (stricmp(argv[i],"-loops")==0) || (stricmp(argv[i],"/loops")==0) )
                                   {
                                   loops=(unsigned long)strtod(argv[i+1],&caractere_non_convertit);
                                   if (loops==0)
                                               bouclage_infinie=TRUE;
                                   else
                                               bouclage_infinie=FALSE;
                                   }
                        if ( (stricmp(argv[i],"-wait")==0) || (stricmp(argv[i],"/wait")==0) )
                                   pause_entre_chaque_frame=(unsigned int)strtod(argv[i+1],&caractere_non_convertit);
                        if ( (stricmp(argv[i],"-timeout")==0) || (stricmp(argv[i],"/timeout")==0) )
                                   timeout=(unsigned int)strtod(argv[i+1],&caractere_non_convertit);

                        // ********************************************************
                        // Choix de l'interface
                        // ********************************************************
                        if (stricmp(argv[i],"-interface")==0)
                                   numero_de_l_interface=(unsigned char)strtod(argv[i+1],&caractere_non_convertit);

                        // ********************************************************
                        // Options de l'entête IP
                        // ********************************************************
                        if ( (stricmp(argv[i],"-ip_source")==0) || (stricmp(argv[i],"/ip_source")==0) )
                                   if (argv[i+1]==0)
                                               ip_source_aleatoire=TRUE;
                                   else
                                               {
                                               ip_source_aleatoire=FALSE;
                                               entete_ipv4.ip_source=(unsigned long)resolution_de_nom(FALSE,argv[i+1]);
                                               }
                        if ( (stricmp(argv[i],"-ip_destination")==0) || (stricmp(argv[i],"/ip_destination")==0) )
                                   {
                                   entete_ipv4.ip_destination=(unsigned long)resolution_de_nom(FALSE,argv[i+1]);
                                   strcpy(ip_destination,convertion_ip(entete_ipv4.ip_destination));
                                   }

                        // ********************************************************
                        // Options de l'entête TCP
                        // ********************************************************
                        if ( (stricmp(argv[i],"-tcp_port_source")==0) || (stricmp(argv[i],"/tcp_port_source")==0) )
                                   if (argv[i+1]==0)
                                               port_source_aleatoire=TRUE;
                                   else
                                               {
                                               port_source_aleatoire=FALSE;
                                               entete_tcp.port_source=htons((unsigned short)strtod(argv[i+1],&caractere_non_convertit));
                                               }
                        if ( (stricmp(argv[i],"-tcp_port_destination")==0) || (stricmp(argv[i],"/tcp_port_destination")==0) )
                                   entete_tcp.port_destination=htons((unsigned short)strtod(argv[i+1],&caractere_non_convertit));

                        // ********************************************************
                        // Options des Datas
                        // ********************************************************
                        if ( (stricmp(argv[i],"-data_size")==0) || (stricmp(argv[i],"/data_size")==0) )
                                   {
                                   longueur_de_data_a_envoyer=(unsigned int)strtod(argv[i+1],&caractere_non_convertit);
                                   memcpy(data_a_envoyer,dimensionnement_de_data_a_envoyer(false, data_a_envoyer, longueur_de_data_a_envoyer, longueur_de_data_a_envoyer), longueur_de_data_a_envoyer);
                                   }
                        }
            }

void Changement_aleatoire_des_valeurs()
            {
            // ********************************************************
            // Random de l'IP Source
            // ********************************************************
            if (ip_source_aleatoire==TRUE)
                        entete_ipv4.ip_source=generation_d_une_adresse_ip_aleatoire(0);

            // ********************************************************
            // Random de l'ID IP
            // ********************************************************
            entete_ipv4.id=(unsigned short)(rand()%65536);                                                        // Tire entre 0 et 65535
                 
            // ********************************************************
            // Random du Port Source
            // ************************************************* *******
            if (port_source_aleatoire==TRUE)
                        entete_tcp.port_source=(unsigned short)(rand()%64511+1+1024);    // Tire entre 1025 et 65535

            // ********************************************************
            // Random de la séquence TCP
            // ********************************************************
            entete_tcp.sequence=(unsigned long)((rand()%65536)*(rand()%65536));                  // Tire entre 0 et 4294967295
            }

void initiation_des_variables_automatiques(void)
            {
            unsigned int i;                                                                                                             // Pour les boucles for
            
            // ********************************************************
            // Préparation des adresses MAC
            // ********************************************************
            if (mac_source_auto==true)
                        {
                        adresse_mac_tampon=recuperation_de_l_adresse_mac( liste_des_interfaces.nom[numero_de_l_interface]);
                        for (i=0;i<6;i++)
                                   entete_mac.source[i]=adresse_mac_tampon.adresse[i];
                        }
            if (mac_destination_auto==true)
                        {
                        adresse_mac_tampon=resolution_arp( liste_des_interfaces.nom[numero_de_l_interface],0,ip_destination,3);
                        for (i=0;i<6;i++)
                                   entete_mac.destination[i]=adresse_mac_tampon.adresse[i];
                        }
            }

void envoi_de_la_trame_winsock(void)
            {
            WSADATA initialisation_win32;
            SOCKADDR_IN information_sur_la_destination;
            SOCKET id_de_la_socket;
            int on;

            // ********************************************************
            // Initialisation de la Socket
            // ********************************************************
            if (WSAStartup(MAKEWORD(2,2),&initialisation_win32)!=0)
                        gestion_des_erreurs(1,"WSAStartup",1,1);      

            // ********************************************************
            // Ouverture d'une Socket
            // ********************************************************
            id_de_la_socket=socket(AF_INET,SOCK_RAW,IPPROTO_RAW);
            if (id_de_la_socket==INVALID_SOCKET)
                        gestion_des_erreurs(1,"socket",1,1);

            // ********************************************************
            // Activation de l'option permettant d'inclure l'entete IP lors de l'emission
            // ********************************************************
            if (setsockopt(id_de_la_socket,IPPROTO_IP,IP_HDRINCL,(char *)&on,sizeof(on))!=0)
                        gestion_des_erreurs(1,"setsockopt",1,1);

            // ********************************************************
            // Calcul du checksum TCP
            // ********************************************************
            entete_tcp.checksum=calcul_du_checksum_tcp(false, entete_ipv4.ip_source, entete_ipv4.ip_destination, entete_tcp,data_a_envoyer, longueur_de_data_a_envoyer);

            // ********************************************************
            // Préparation de la trame à envoyé
            // ********************************************************
            memcpy(trame_a_envoyer,(unsigned short *)&entete_ipv4,sizeof(struct ipv4));
            memcpy(trame_a_envoyer+sizeof(struct ipv4),(unsigned short *)&entete_tcp,sizeof(struct tcp));
            memcpy(trame_a_envoyer+sizeof(struct ipv4)+sizeof(struct tcp),data_a_envoyer,longueur_de_data_a_envoyer);

            // ********************************************************
            // Paramètre nécessaire au sendto
            // ********************************************************
            information_sur_la_destination.sin_family=AF_INET;
            information_sur_la_destination.sin_addr.s_addr=entete_ipv4.ip_destination;

            // ********************************************************
            // Démarrage du chrono
            // ********************************************************
            QueryPerformanceCounter((LARGE_INTEGER *) &temps_de_reponse1);

            // ********************************************************
            // Envoi de la trame en winsock
            // ********************************************************
            nombre_de_caractere_emis=sendto(id_de_la_socket, (char *)trame_a_envoyer,sizeof(struct ipv4)+sizeof(struct tcp)+ longueur_de_data_a_envoyer,0,(struct sockaddr*)&information_sur_la_destination, sizeof(information_sur_la_destination));
            if (nombre_de_caractere_emis==-1)
                        gestion_des_erreurs(1,"sendto",1,1);

            // ********************************************************
            // Fermeture de la socket correspondant à la commande socket()
            // ********************************************************
            closesocket(id_de_la_socket);

            // ********************************************************
            // quite propement le winsock ouvert avec la commande WSAStartup
            // ********************************************************
            WSACleanup(); //  (A appeller autant de fois qu'il a été ouvert)
            }

void envoi_de_la_trame_pcap(void)
            {
            pcap_t *pointeur_interface;
            char buffer_d_erreur[PCAP_ERRBUF_SIZE];

            // ********************************************************
            // Accède à l'interface
            // ********************************************************
            if ((pointeur_interface=pcap_open_live( liste_des_interfaces.nom[numero_de_l_interface],65536, 0,1000,buffer_d_erreur))==NULL)
                        gestion_des_erreurs(1,"pcap_open_live",1,1);

            // ********************************************************
            // Calcul du checksum TCP
            // ********************************************************
            entete_tcp.checksum=calcul_du_checksum_tcp(false, entete_ipv4.ip_source, entete_ipv4.ip_destination, entete_tcp,data_a_envoyer, longueur_de_data_a_envoyer);
            // ********************************************************
            // Calcul de la longueur totale
            // ********************************************************
            entete_ipv4.length=htons((unsigned short)(sizeof(struct ipv4)+sizeof(struct tcp)+longueur_de_data_a_envoyer));

            // ********************************************************
            // Calcul du checksum IP
            // ********************************************************
            entete_ipv4.checksum=calcul_du_checksum_ip(false,entete_ipv4);

            // ********************************************************
            // Préparation de la trame à envoyé
            // ********************************************************
            memcpy(trame_a_envoyer,(unsigned short *)&entete_mac,sizeof(struct mac));   
            memcpy(trame_a_envoyer+sizeof(struct mac),(unsigned short *)&entete_ipv4,sizeof(struct ipv4));
            memcpy(trame_a_envoyer+sizeof(struct mac)+sizeof(struct ipv4),(unsigned short *)&entete_tcp,sizeof(struct tcp));
            memcpy(trame_a_envoyer+sizeof(struct mac)+sizeof(struct ipv4)+sizeof(struct tcp),data_a_envoyer,longueur_de_data_a_envoyer);

            // ********************************************************
            // Démarrage du chrono
            // ********************************************************
            QueryPerformanceCounter((LARGE_INTEGER *) &temps_de_reponse1);

            // ********************************************************
            // Envoi de la trame
            // ********************************************************
            if(pcap_sendpacket(pointeur_interface,trame_a_envoyer,sizeof(struct mac)+sizeof(struct ipv4)+sizeof(struct tcp)+longueur_de_data_a_envoyer)!=0)
                        gestion_des_erreurs(1,"pcap_sendpacket",1,1);                      

            // ********************************************************
            // Fermeture de l'accès à l'interface
            // ********************************************************
            pcap_close(pointeur_interface);                       
            }

void reception_de_la_trame()
            {
            WSADATA initialisation_win32;
            SOCKADDR_IN information_sur_la_source;
            SOCKET id_de_la_socket_ecoute;
            DWORD  lpcbBytesReturned;
            int tampon; // Variable temporaire
            int duree_de_la_boucle;
            BOOL sortie_de_la_boucle;
            int nombre_de_caractere_recu;
            char buffer_de_reception[65535];
            double temps_de_reponse; // Variable indiquant le temps écoulé entre l'envoi et la reception

            // ********************************************************
            // Initialisation de la Socket
            // ********************************************************
            if (WSAStartup(MAKEWORD(2,2),&initialisation_win32)!=0)
                        gestion_des_erreurs(1,"WSAStartup",1,1);      

            // ********************************************************
            // Ouverture d'une Socket
            // ********************************************************
            id_de_la_socket_ecoute=socket(AF_INET,SOCK_RAW,IPPROTO_IP);
            if (id_de_la_socket_ecoute==INVALID_SOCKET)
                        gestion_des_erreurs(1,"socket",1,1);

            // ********************************************************
            // Lien entre la socket et l'IP d'écoute
            // ********************************************************
            information_sur_la_source.sin_family=AF_INET;
            information_sur_la_source.sin_addr.S_un.S_addr=entete_ipv4.ip_source;
            if (bind( id_de_la_socket_ecoute,(SOCKADDR *)&information_sur_la_source, sizeof(information_sur_la_source))==SOCKET_ERROR)
                        gestion_des_erreurs(1,"bind",1,1);

            // ********************************************************
            // Choix du mode de la socket
            // ********************************************************
            tampon=1;
//          if (WSAIoctl(id_de_la_socket_ecoute, SIO_RCVALL,&tampon,sizeof(tampon),NULL,0, &lpcbBytesReturned,NULL,NULL)==SOCKET_ERROR)
//                      gestion_des_erreurs(1,"wsaioctl",1,1);

            // ********************************************************
            // Passage de la socket en mode non bloquant
            // ********************************************************
            tampon=1;
            // La commande recv attend 1 (on) ms avant de rendre la main
            if (setsockopt(id_de_la_socket_ecoute,SOL_SOCKET,SO_RCVTIMEO,(char *)&tampon,sizeof(tampon))!=0)
                        gestion_des_erreurs(1,"setsockopt",1,1);

            // ********************************************************
            // Création de la boucle d'attente
            // ********************************************************
            QueryPerformanceFrequency((LARGE_INTEGER *)&cpu_frequence);
            duree_de_la_boucle=GetTickCount();
            sortie_de_la_boucle=FALSE;
            while (sortie_de_la_boucle==false)
                        {
                        nombre_de_caractere_recu=recv(id_de_la_socket_ecoute,buffer_de_reception,65535,0);
                        if (GetTickCount()-duree_de_la_boucle>(unsigned)(timeout*1000))
                                   {
                                   sortie_de_la_boucle=TRUE;
                                   printf("Timeout, sorry, but I didn't receive the answer SYN/ACK or RST/ACK.\n");
                                   }
                        else if (nombre_de_caractere_recu!=-1)
                                   {
                                   // ********************************************************
                                   // Extraction et  des valeurs recues
                                   // ********************************************************
                                   entete_ipv4_reception=(struct ipv4 *)buffer_de_reception;
                                   entete_tcp_reception=(struct tcp *)(buffer_de_reception+20);

                                   if (entete_ipv4_reception->ip_source==entete_ipv4.ip_destination)
                                   if (entete_ipv4_reception->ip_destination==entete_ipv4.ip_source)
                                   if (entete_ipv4_reception->type==6)
                                   if (entete_tcp_reception->port_source==entete_tcp.port_destination)
                                   if (entete_tcp_reception->port_destination==entete_tcp.port_source)
                                   if (entete_tcp_reception->flag_ack==1)
                                   if ( (entete_tcp_reception->flag_syn==1) || (entete_tcp_reception->flag_rst==1) )
                                               {
                                               sortie_de_la_boucle=TRUE;

                                               // ********************************************************
                                               // Arrêt du chrono
                                               // ********************************************************
                                               QueryPerformanceCounter((LARGE_INTEGER *)&temps_de_reponse2);

                                               // ********************************************************
                                               // Calcul du temps de réponse
                                               // ********************************************************
                                               temps_de_reponse=( (double) ( (temps_de_reponse2.QuadPart - temps_de_reponse1.QuadPart) * (double) 1000.0 / (double) cpu_frequence.QuadPart) );

                                               // ********************************************************
                                               // Affichage du résultat
                                               // ********************************************************
                                               printf("Time : %.2f ms",temps_de_reponse);
                                               if (entete_tcp_reception->flag_syn==1)
                                                           printf("  -   SYN ACK received from %s",convertion_ip(entete_ipv4_reception->ip_source));
                                               else
                                                           printf("  -   RST ACK received from %s",convertion_ip(entete_ipv4_reception->ip_source));
                                               printf(" to %s",convertion_ip(entete_ipv4_reception->ip_destination));
                                               printf("\n");
//                                             printf("   %d Octets",nombre_de_caractere_recu-40);
//                                             printf("   ttl : %d\n",entete_ipv4_reception->ttl);
                                               }
                                   }
                        }
            }

6 – Les vidéos

7 – Discussion autour de l’outil Ping TCP

Vous pouvez poser toutes vos questions, faire part de vos remarques et partager vos expériences à propos de l’outil Ping TCP. Pour cela, n’hésitez pas à laisser un commentaire ci-dessous :