Code source du PING

Code source du PING - C++ - Programmation

Marsh Posté le 27-12-2002 à 16:16:23    

Bonjour. je commence cette année la programmation,donc je cherche des ressoureces interéssantes pour progresser.
J'ai entendu dire que lire du code etait un bon moyen
de progresser. Dans ce cas ou peut on trouver du code
source a lire?
 
et ou pourais-je en particulier trouver le code
source du programe PING?
 
merci d'avance :)


---------------
http://www.core-tx.com
Reply

Marsh Posté le 27-12-2002 à 16:16:23   

Reply

Marsh Posté le 27-12-2002 à 17:21:20    

tu peux le trouvé dans msdn je crois
ca utilise ipx il me semble

Reply

Marsh Posté le 27-12-2002 à 17:27:24    

Sanglier04 a écrit :

tu peux le trouvé dans msdn je crois
ca utilise ipx il me semble

N'importe koi toi :heink:  
Tu peux utiliser les RAW sockets..
 

Code :
  1. // Module Name: Ping.c
  2. //
  3. // Description:
  4. //    This sample illustrates how an ICMP ping app can be written
  5. //    using the SOCK_RAW socket type and IPPROTO_ICMP protocol.
  6. //    By creating a raw socket, the underlying layer does not change
  7. //    the protocol header so that when we submit the ICMP header
  8. //    nothing is changed so that the receiving end will see an  
  9. //    ICMP packet. Additionally, we use the record route IP option
  10. //    to get a round trip path to the endpoint. Note that the size
  11. //    of the IP option header that records the route is limited to
  12. //    nine IP addresses.
  13. //
  14. // Compile:
  15. //     cl -o Ping Ping.c ws2_32.lib /Zp1
  16. //
  17. // Command Line Options/Parameters:
  18. //     Ping [host] [packet-size]
  19. //     
  20. //     host         String name of host to ping
  21. //     packet-size  Integer size of packet to send  
  22. //                      (smaller than 1024 bytes)
  23. //
  24. //#pragma pack(1)
  26. #define WIN32_LEAN_AND_MEAN
  27. #include <winsock2.h>
  28. #include <ws2tcpip.h>
  29. #include <stdio.h>
  30. #include <stdlib.h>
  32. #define IP_RECORD_ROUTE  0x7
  33. //  
  34. // IP header structure
  35. //
  36. typedef struct _iphdr
  37. {
  38.     unsigned int   h_len:4;        // Length of the header
  39.     unsigned int   version:4;      // Version of IP
  40.     unsigned char  tos;            // Type of service
  41.     unsigned short total_len;      // Total length of the packet
  42.     unsigned short ident;          // Unique identifier
  43.     unsigned short frag_and_flags; // Flags
  44.     unsigned char  ttl;            // Time to live
  45.     unsigned char  proto;          // Protocol (TCP, UDP etc)
  46.     unsigned short checksum;       // IP checksum
  48.     unsigned int   sourceIP;
  49.     unsigned int   destIP;
  50. } IpHeader;
  52. #define ICMP_ECHO        8
  53. #define ICMP_ECHOREPLY   0
  54. #define ICMP_MIN         8 // Minimum 8-byte ICMP packet (header)
  56. //
  57. // ICMP header structure
  58. //
  59. typedef struct _icmphdr
  60. {
  61.     BYTE   i_type;
  62.     BYTE   i_code;                 // Type sub code
  63.     USHORT i_cksum;
  64.     USHORT i_id;
  65.     USHORT i_seq;
  66.     // This is not the standard header, but we reserve space for time
  67.     ULONG  timestamp;
  68. } IcmpHeader;
  70. //
  71. // IP option header - use with socket option IP_OPTIONS
  72. //
  73. typedef struct _ipoptionhdr
  74. {
  75.     unsigned char        code;        // Option type
  76.     unsigned char        len;         // Length of option hdr
  77.     unsigned char        ptr;         // Offset into options
  78.     unsigned long        addr[9];     // List of IP addrs
  79. } IpOptionHeader;
  81. #define DEF_PACKET_SIZE  32        // Default packet size
  82. #define MAX_PACKET       1024      // Max ICMP packet size
  83. #define MAX_IP_HDR_SIZE  60        // Max IP header size w/options
  85. BOOL  bRecordRoute;
  86. int   datasize;
  87. char *lpdest;
  89. //
  90. // Function: usage
  91. //
  92. // Description:
  93. //    Print usage information
  94. //
  95. void usage(char *progname)
  96. {
  97.     printf("usage: ping -r <host> [data size]\n" );
  98.     printf("       -r           record route\n" );
  99.     printf("        host        remote machine to ping\n" );
  100.     printf("        datasize    can be up to 1KB\n" );
  101.     ExitProcess(-1);
  102. }
  104. //  
  105. // Function: FillICMPData
  106. //
  107. // Description:
  108. //    Helper function to fill in various fields for our ICMP request
  109. //
  110. void FillICMPData(char *icmp_data, int datasize)
  111. {
  112.     IcmpHeader *icmp_hdr = NULL;
  113.     char       *datapart = NULL;
  115.     icmp_hdr = (IcmpHeader*)icmp_data;
  116.     icmp_hdr->i_type = ICMP_ECHO;        // Request an ICMP echo
  117.     icmp_hdr->i_code = 0;
  118.     icmp_hdr->i_id = (USHORT)GetCurrentProcessId();
  119.     icmp_hdr->i_cksum = 0;
  120.     icmp_hdr->i_seq = 0;
  121.  
  122.     datapart = icmp_data + sizeof(IcmpHeader);
  123.     //
  124.     // Place some junk in the buffer
  125.     //
  126.     memset(datapart,'E', datasize - sizeof(IcmpHeader));
  127. }
  129. //  
  130. // Function: checksum
  131. //
  132. // Description:
  133. //    This function calculates the 16-bit one's complement sum
  134. //    of the supplied buffer (ICMP) header
  135. //
  136. USHORT checksum(USHORT *buffer, int size)
  137. {
  138.     unsigned long cksum=0;
  140.     while (size > 1)
  141.     {
  142.         cksum += *buffer++;
  143.         size -= sizeof(USHORT);
  144.     }
  145.     if (size)
  146.     {
  147.         cksum += *(UCHAR*)buffer;
  148.     }
  149.     cksum = (cksum >> 16) + (cksum & 0xffff);
  150.     cksum += (cksum >>16);
  151.     return (USHORT)(~cksum);
  152. }
  154. //
  155. // Function: DecodeIPOptions
  156. //
  157. // Description:
  158. //    If the IP option header is present, find the IP options
  159. //    within the IP header and print the record route option
  160. //    values
  161. //
  162. void DecodeIPOptions(char *buf, int bytes)
  163. {
  164.     IpOptionHeader *ipopt = NULL;
  165.     IN_ADDR         inaddr;
  166.     int             i;
  167.     HOSTENT        *host = NULL;
  169.     ipopt = (IpOptionHeader *)(buf + 20);
  171.     printf("RR:   " );
  172.     for(i = 0; i < (ipopt->ptr / 4) - 1; i++)
  173.     {
  174.         inaddr.S_un.S_addr = ipopt->addr[i];
  175.         if (i != 0)
  176.             printf("      " );
  177.         host = gethostbyaddr((char *)&inaddr.S_un.S_addr,
  178.                     sizeof(inaddr.S_un.S_addr), AF_INET);
  179.         if (host)
  180.             printf("(%-15s) %s\n", inet_ntoa(inaddr), host->h_name);
  181.         else
  182.             printf("(%-15s)\n", inet_ntoa(inaddr));
  183.     }
  184.     return;
  185. }
  187. //
  188. // Function: DecodeICMPHeader
  189. //
  190. // Description:
  191. //    The response is an IP packet. We must decode the IP header to
  192. //    locate the ICMP data.
  193. //
  194. void DecodeICMPHeader(char *buf, int bytes,
  195.     struct sockaddr_in *from)
  196. {
  197.     IpHeader       *iphdr = NULL;
  198.     IcmpHeader     *icmphdr = NULL;
  199.     unsigned short  iphdrlen;
  200.     DWORD           tick;
  201.     static   int    icmpcount = 0;
  203.     iphdr = (IpHeader *)buf;
  204. // Number of 32-bit words * 4 = bytes
  205.     iphdrlen = iphdr->h_len * 4;
  206.     tick = GetTickCount();
  208.     if ((iphdrlen == MAX_IP_HDR_SIZE) && (!icmpcount))
  209.         DecodeIPOptions(buf, bytes);
  211.     if (bytes  < iphdrlen + ICMP_MIN)
  212.     {
  213.         printf("Too few bytes from %s\n",
  214.             inet_ntoa(from->sin_addr));
  215.     }
  216.     icmphdr = (IcmpHeader*)(buf + iphdrlen);
  218.     if (icmphdr->i_type != ICMP_ECHOREPLY)
  219.     {
  220.         printf("nonecho type %d recvd\n", icmphdr->i_type);
  221.         return;
  222.     }
  223.     // Make sure this is an ICMP reply to something we sent!
  224.     //
  225.     if (icmphdr->i_id != (USHORT)GetCurrentProcessId())
  226.     {
  227.         printf("someone else's packet!\n" );
  228.         return ;
  229.     }
  230.     printf("%d bytes from %s:", bytes, inet_ntoa(from->sin_addr));
  231.     printf(" icmp_seq = %d. ", icmphdr->i_seq);
  232.     printf(" time: %d ms", tick - icmphdr->timestamp);
  233.     printf("\n" );
  235.     icmpcount++;
  236.     return;
  237. }
  239. void ValidateArgs(int argc, char **argv)
  240. {
  241.     int                i;
  243.     bRecordRoute = FALSE;
  244.     lpdest = NULL;
  245.     datasize = DEF_PACKET_SIZE;
  246.    
  247.     for(i = 1; i < argc; i++)
  248.     {
  249.         if ((argv[i][0] == '-') || (argv[i][0] == '/'))
  250.         {
  251.             switch (tolower(argv[i][1]))
  252.             {
  253.                 case 'r':        // Record route option
  254.                     bRecordRoute = TRUE;
  255.                     break;
  256.                 default:
  257.                     usage(argv[0]);
  258.                     break;
  259.             }
  260.         }
  261.         else if (isdigit(argv[i][0]))
  262.             datasize = atoi(argv[i]);
  263.         else
  264.             lpdest = argv[i];
  265.     }
  266. }
  267.        
  268. //
  269. // Function: main
  270. //
  271. // Description:
  272. //    Setup the ICMP raw socket, and create the ICMP header. Add
  273. //    the appropriate IP option header, and start sending ICMP
  274. //    echo requests to the endpoint. For each send and receive,
  275. //    we set a timeout value so that we don't wait forever for a  
  276. //    response in case the endpoint is not responding. When we
  277. //    receive a packet decode it.
  278. //
  279. int main(int argc, char **argv)
  280. {
  282.     WSADATA            wsaData;
  283.     SOCKET             sockRaw = INVALID_SOCKET;
  284.     struct sockaddr_in dest,
  285.                        from;
  286.     int                bread,
  287.                        fromlen = sizeof(from),
  288.                        timeout = 1000,
  289.                        ret;
  290.     char              *icmp_data = NULL,
  291.                       *recvbuf = NULL;
  292.     unsigned int       addr = 0;
  293.     USHORT             seq_no = 0;
  294.     struct hostent    *hp = NULL;
  295.     IpOptionHeader     ipopt;
  298.     if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0)
  299.     {
  300.         printf("WSAStartup() failed: %d\n", GetLastError());
  301.         return -1;
  302.     }
  303.     ValidateArgs(argc, argv);
  305.     //
  306.     // WSA_FLAG_OVERLAPPED flag is required for SO_RCVTIMEO,  
  307.     // SO_SNDTIMEO option. If NULL is used as last param for  
  308.     // WSASocket, all I/O on the socket is synchronous, the  
  309.     // internal user mode wait code never gets a chance to  
  310.     // execute, and therefore kernel-mode I/O blocks forever.  
  311.     // A socket created via the socket function has the over-
  312.  // lapped I/O attribute set internally. But here we need  
  313.  // to use WSASocket to specify a raw socket.
  314.     //
  315.     // If you want to use timeout with a synchronous  
  316.     // nonoverlapped socket created by WSASocket with last  
  317.  // param set to NULL, you can set the timeout by using  
  318.  // the select function, or you can use WSAEventSelect and  
  319.  // set the timeout in the WSAWaitForMultipleEvents  
  320.  // function.
  321.     //
  322.     sockRaw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0,
  323.                          WSA_FLAG_OVERLAPPED);
  324.     if (sockRaw == INVALID_SOCKET)
  325.     {
  326.         printf("WSASocket() failed: %d\n", WSAGetLastError());
  327.         return -1;
  328.     }
  329.     if (bRecordRoute)
  330.     {
  331.         // Setup the IP option header to go out on every ICMP packet
  332.         //
  333.         ZeroMemory(&ipopt, sizeof(ipopt));
  334.         ipopt.code = IP_RECORD_ROUTE; // Record route option
  335.         ipopt.ptr  = 4;               // Point to the first addr offset
  336.         ipopt.len  = 39;              // Length of option header
  337.  
  338.         ret = setsockopt(sockRaw, IPPROTO_IP, IP_OPTIONS,
  339.             (char *)&ipopt, sizeof(ipopt));
  340.         if (ret == SOCKET_ERROR)
  341.         {
  342.             printf("setsockopt(IP_OPTIONS) failed: %d\n",
  343.                 WSAGetLastError());
  344.         }
  345.     }
  346.     // Set the send/recv timeout values
  347.     //
  348.     bread = setsockopt(sockRaw, SOL_SOCKET, SO_RCVTIMEO,
  349.                 (char*)&timeout, sizeof(timeout));
  350.     if(bread == SOCKET_ERROR)
  351.     {
  352.         printf("setsockopt(SO_RCVTIMEO) failed: %d\n",
  353.             WSAGetLastError());
  354.         return -1;
  355.     }
  356.     timeout = 1000;
  357.     bread = setsockopt(sockRaw, SOL_SOCKET, SO_SNDTIMEO,
  358.                 (char*)&timeout, sizeof(timeout));
  359.     if (bread == SOCKET_ERROR)
  360.     {
  361.         printf("setsockopt(SO_SNDTIMEO) failed: %d\n",
  362.             WSAGetLastError());
  363.         return -1;
  364.     }
  365.     memset(&dest, 0, sizeof(dest));
  366.     //
  367.     // Resolve the endpoint's name if necessary
  368.     //
  369.     dest.sin_family = AF_INET;
  370.     if ((dest.sin_addr.s_addr = inet_addr(lpdest)) == INADDR_NONE)
  371.     {
  372.         if ((hp = gethostbyname(lpdest)) != NULL)
  373.         {
  374.             memcpy(&(dest.sin_addr), hp->h_addr, hp->h_length);
  375.             dest.sin_family = hp->h_addrtype;
  376.             printf("dest.sin_addr = %s\n", inet_ntoa(dest.sin_addr));
  377.         }
  378.         else
  379.         {
  380.             printf("gethostbyname() failed: %d\n",
  381.                 WSAGetLastError());
  382.             return -1;
  383.         }
  384.     }       
  386.     //  
  387.     // Create the ICMP packet
  388.     //       
  389.     datasize += sizeof(IcmpHeader); 
  391.     icmp_data = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  392.                   MAX_PACKET);
  393.     recvbuf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
  394.                   MAX_PACKET);
  395.     if (!icmp_data)
  396.     {
  397.         printf("HeapAlloc() failed: %d\n", GetLastError());
  398.         return -1;
  399.     }
  400.     memset(icmp_data,0,MAX_PACKET);
  401.     FillICMPData(icmp_data,datasize);
  402.     //
  403.     // Start sending/receiving ICMP packets
  404.     //
  405.     while(1)
  406.     {
  407.         static int nCount = 0;
  408.         int        bwrote;
  409.                
  410.         if (nCount++ == 4)
  411.             break;
  412.                
  413.         ((IcmpHeader*)icmp_data)->i_cksum = 0;
  414.         ((IcmpHeader*)icmp_data)->timestamp = GetTickCount();
  415.         ((IcmpHeader*)icmp_data)->i_seq = seq_no++;
  416.         ((IcmpHeader*)icmp_data)->i_cksum =
  417.             checksum((USHORT*)icmp_data, datasize);
  419.         bwrote = sendto(sockRaw, icmp_data, datasize, 0,
  420.                      (struct sockaddr*)&dest, sizeof(dest));
  421.         if (bwrote == SOCKET_ERROR)
  422.         {
  423.             if (WSAGetLastError() == WSAETIMEDOUT)
  424.             {
  425.                 printf("timed out\n" );
  426.                 continue;
  427.             }
  428.             printf("sendto() failed: %d\n", WSAGetLastError());
  429.             return -1;
  430.         }
  431.         if (bwrote < datasize)
  432.         {
  433.             printf("Wrote %d bytes\n", bwrote);
  434.         }
  435.         bread = recvfrom(sockRaw, recvbuf, MAX_PACKET, 0,
  436.                     (struct sockaddr*)&from, &fromlen);
  437.         if (bread == SOCKET_ERROR)
  438.         {
  439.             if (WSAGetLastError() == WSAETIMEDOUT)
  440.             {
  441.                 printf("timed out\n" );
  442.                 continue;
  443.             }
  444.             printf("recvfrom() failed: %d\n", WSAGetLastError());
  445.             return -1;
  446.         }
  447.         DecodeICMPHeader(recvbuf, bread, &from);
  449.         Sleep(1000);
  450.     }
  451.     // Cleanup
  452.     //
  453.     if (sockRaw != INVALID_SOCKET)
  454.         closesocket(sockRaw);
  455.     HeapFree(GetProcessHeap(), 0, recvbuf);
  456.     HeapFree(GetProcessHeap(), 0, icmp_data);
  458.     WSACleanup();
  459.     return 0;
  460. }


 
Ah oui,  [:google] c'est bien parfois tu sais..

Reply

Marsh Posté le 27-12-2002 à 17:33:00    

+1 et d'accord avec toi mais donner le lien où tu as trouvé le code serait la moindre des choses ;)
 
:hello:

Reply

Marsh Posté le 27-12-2002 à 17:34:11    

Bah j'ai donné tous les mots clés, y'a qu'à les retapper dans google, raw socket ping c++ et ça se trouve en 1ère page :)
 
 :hello:


Message édité par *syl* le 27-12-2002 à 17:34:51
Reply

Marsh Posté le 27-12-2002 à 17:36:31    

au pasage une question :
#define WIN32_LEAN_AND_MEAN
j'ai jamais pigé ce que ca fesait. A quoi ca sert ?


---------------
FAQ fclc++ - FAQ C++ - C++ FAQ Lite
Reply

Marsh Posté le 27-12-2002 à 17:38:01    

1ère réponse dans google :

Citation :

It disables or enables some parts of typedefs in windows.h.


 
 :D

Reply

Marsh Posté le 27-12-2002 à 18:00:57    

merci pour ça:)
sinon pouriez vous me conseiller un site ou l'on trouve
des codes sources de programmes simples?


---------------
http://www.core-tx.com
Reply

Marsh Posté le 27-12-2002 à 18:01:46    

HelloWorld a écrit :

au pasage une question :
#define WIN32_LEAN_AND_MEAN
j'ai jamais pigé ce que ca fesait. A quoi ca sert ?


recherche google msdn, + pratique :
http://www.google.com/search?sourc [...] ND%5FMEAN+

Reply

Marsh Posté le 27-12-2002 à 18:02:53    

youdontcare>
"To see the list of header files specifically excluded from MFC builds, look at the definition of WIN32_LEAN_AND_MEAN in WINDOWS.H"
bon ben je vais faire une petite recherche dans les header windows alors ... :crazy:
 
sky99>ca depent quels genres de progs, et ce que tu entends par simple.
la msdn + sdk fournit plein de sources simples pour expliquer l'utilisation de certaines fonctions.


Message édité par HelloWorld le 27-12-2002 à 18:05:26

---------------
FAQ fclc++ - FAQ C++ - C++ FAQ Lite
Reply

Marsh Posté le 27-12-2002 à 18:02:53   

Reply

Marsh Posté le 27-12-2002 à 18:03:48    

Sky99 a écrit :

merci pour ça:)
sinon pouriez vous me conseiller un site ou l'on trouve
des codes sources de programmes simples?

question très vague ... tu peux par exemple downloader les sources de linux / freebsd et regarder les sources des commandes les plus simples ... chopper les sources de quake ... bref, y'a de quoi faire.

Reply

Marsh Posté le 27-12-2002 à 19:01:59    

merci pour ça:)
sinon pouriez vous me conseiller un site ou l'on trouve
des codes sources de programmes simples?


---------------
http://www.core-tx.com
Reply

Marsh Posté le 27-12-2002 à 19:12:15    

tain!!
 
les [][] c mal   :kaola: :pfff:


---------------
"-Dites 33. -Export!!" [:nokbilong]
Reply

Marsh Posté le 27-12-2002 à 19:12:55    

Sky99 a écrit :

merci pour ça:)
sinon pouriez vous me conseiller un site ou l'on trouve
des codes sources de programmes simples?


 
 
www.developpez.com doit avoir avoir des tuts avce des exemples


---------------
"-Dites 33. -Export!!" [:nokbilong]
Reply

Marsh Posté le 27-12-2002 à 19:31:58    

Nokbilong a écrit :

tain!!
 
les [][] c mal   :kaola: :pfff:  


ça veut dire quoi ça?
si c'est a propos des crochets dans le titre [C,C++]
je ne les ai pas mis, ils sont insérés automatiquement...


---------------
http://www.core-tx.com
Reply

Marsh Posté le 27-12-2002 à 19:34:00    

sinon pour les programmes,je pense que je pourrai me debrouiller avec ce que j'ai la...
 
merci beaucoup!


---------------
http://www.core-tx.com
Reply

Marsh Posté le 27-12-2002 à 19:39:17    

Sky99 a écrit :


ça veut dire quoi ça?
si c'est a propos des crochets dans le titre [C,C++]
je ne les ai pas mis, ils sont insérés automatiquement...


 
 
nop :)
 
pour les **char
y'a des [][]
perso j'aime pas :/
 
(je dis pas que c pas pratique dans certain cas hein)
mais c vraiment la chiotte pour lire le code je trouve
 
y'en a dans le code + haut


---------------
"-Dites 33. -Export!!" [:nokbilong]
Reply

Marsh Posté le 28-12-2002 à 00:01:22    

Le code d'iputils-ping :
 

Code :
  1. /*
  2. * Copyright (c) 1989 The Regents of the University of California.
  3. * All rights reserved.
  4. *
  5. * This code is derived from software contributed to Berkeley by
  6. * Mike Muuss.
  7. *
  8. * Redistribution and use in source and binary forms, with or without
  9. * modification, are permitted provided that the following conditions
  10. * are met:
  11. * 1. Redistributions of source code must retain the above copyright
  12. *    notice, this list of conditions and the following disclaimer.
  13. * 2. Redistributions in binary form must reproduce the above copyright
  14. *    notice, this list of conditions and the following disclaimer in the
  15. *    documentation and/or other materials provided with the distribution.
  16. * 3. All advertising materials mentioning features or use of this software
  17. *    must display the following acknowledgement:
  18. * This product includes software developed by the University of
  19. * California, Berkeley and its contributors.
  20. * 4. Neither the name of the University nor the names of its contributors
  21. *    may be used to endorse or promote products derived from this software
  22. *    without specific prior written permission.
  23. *
  24. * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25. * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26. * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27. * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28. * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29. * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30. * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31. * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32. * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33. * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34. * SUCH DAMAGE.
  35. */
  37. #ifndef lint
  38. char copyright[] =
  39. "@(#) Copyright (c) 1989 The Regents of the University of California.\n\
  40. All rights reserved.\n";
  41. #endif /* not lint */
  43. /*
  44. *   P I N G . C
  45. *
  46. * Using the InterNet Control Message Protocol (ICMP) "ECHO" facility,
  47. * measure round-trip-delays and packet loss across network paths.
  48. *
  49. * Author -
  50. * Mike Muuss
  51. * U. S. Army Ballistic Research Laboratory
  52. * December, 1983
  53. *
  54. * Status -
  55. * Public Domain.  Distribution Unlimited.
  56. * Bugs -
  57. * More statistics could always be gathered.
  58. * This program has to run SUID to ROOT to access the ICMP socket.
  59. */
  61. #include "ping_common.h"
  63. #include <netinet/ip.h>
  64. #include <netinet/ip_icmp.h>
  67. #define MAXIPLEN 60
  68. #define MAXICMPLEN 76
  69. #define NROUTES  9  /* number of record route slots */
  70. #define TOS_MAX  255  /* 8-bit TOS field */
  73. static int ts_type;
  74. static int nroute = 0;
  75. static __u32 route[10];
  79. struct sockaddr_in whereto; /* who to ping */
  80. int optlen = 0;
  81. int settos = 0;   /* Set TOS, Precendence or other QOS options */
  82. int icmp_sock;   /* socket file descriptor */
  83. u_char outpack[0x10000];
  84. int maxpacket = sizeof(outpack);
  86. static int broadcast_pings = 0;
  88. static char *pr_addr(__u32);
  89. static void pr_options(unsigned char * cp, int hlen);
  90. static void pr_iph(struct iphdr *ip);
  91. static void usage(void) __attribute__((noreturn));
  92. static u_short in_cksum(const u_short *addr, int len, u_short salt);
  93. static void pr_icmph(__u8 type, __u8 code, __u32 info, struct icmphdr *icp);
  94. static int parsetos(char *str);
  96. static struct {
  97. struct cmsghdr cm;
  98. struct in_pktinfo ipi;
  99. } cmsg = { {sizeof(struct cmsghdr) + sizeof(struct in_pktinfo), SOL_IP, IP_PKTINFO},
  100.    {0, }};
  101. int cmsg_len;
  103. struct sockaddr_in source;
  104. char *device;
  105. int pmtudisc = -1;
  108. int
  109. main(int argc, char **argv)
  110. {
  111. struct hostent *hp;
  112. int ch, hold, packlen;
  113. int socket_errno;
  114. u_char *packet;
  115. char *target, hnamebuf[MAXHOSTNAMELEN];
  116. char rspace[3 + 4 * NROUTES + 1]; /* record route space */
  118. icmp_sock = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
  119. socket_errno = errno;
  121. uid = getuid();
  122. setuid(uid);
  124. source.sin_family = AF_INET;
  126. preload = 1;
  127. while ((ch = getopt(argc, argv, COMMON_OPTSTR "bRT:" )) != EOF) {
  128.  switch(ch) {
  129.  case 'b':
  130.          broadcast_pings = 1;
  131.   break;
  132.  case 'Q':
  133.   settos = parsetos(optarg);
  134.   if (settos &&
  135.       (setsockopt(icmp_sock, IPPROTO_IP, IP_TOS,
  136.     (char *)&settos, sizeof(int)) < 0)) {
  137.    perror("ping: error setting QOS sockopts" );
  138.    exit(2);
  139.   }
  140.   break;
  141.  case 'R':
  142.   if (options & F_TIMESTAMP) {
  143.    fprintf(stderr, "Only one of -T or -R may be used\n" );
  144.    exit(2);
  145.   }
  146.   options |= F_RROUTE;
  147.   break;
  148.  case 'T':
  149.   if (options & F_RROUTE) {
  150.    fprintf(stderr, "Only one of -T or -R may be used\n" );
  151.    exit(2);
  152.   }
  153.   options |= F_TIMESTAMP;
  154.   if (strcmp(optarg, "tsonly" ) == 0)
  155.    ts_type = IPOPT_TS_TSONLY;
  156.   else if (strcmp(optarg, "tsandaddr" ) == 0)
  157.    ts_type = IPOPT_TS_TSANDADDR;
  158.   else if (strcmp(optarg, "tsprespec" ) == 0)
  159.    ts_type = IPOPT_TS_PRESPEC;
  160.   else {
  161.    fprintf(stderr, "Invalid timestamp type\n" );
  162.    exit(2);
  163.   }
  164.   break;
  165.  case 'I':
  166.  {
  167.   char dummy;
  168.   int i1, i2, i3, i4;
  170.   if (sscanf(optarg, "%u.%u.%u.%u%c",
  171.       &i1, &i2, &i3, &i4, &dummy) == 4) {
  172.    __u8 *ptr;
  173.    ptr = (__u8*)&source.sin_addr;
  174.    ptr[0] = i1;
  175.    ptr[1] = i2;
  176.    ptr[2] = i3;
  177.    ptr[3] = i4;
  178.    options |= F_STRICTSOURCE;
  179.   } else {
  180.    device = optarg;
  181.   }
  182.   break;
  183.  }
  184.  case 'M':
  185.   if (strcmp(optarg, "do" ) == 0)
  186.    pmtudisc = IP_PMTUDISC_DO;
  187.   else if (strcmp(optarg, "dont" ) == 0)
  188.    pmtudisc = IP_PMTUDISC_DONT;
  189.   else if (strcmp(optarg, "want" ) == 0)
  190.    pmtudisc = IP_PMTUDISC_WANT;
  191.   else {
  192.    fprintf(stderr, "ping: wrong value for -M: do, dont, want are valid ones.\n" );
  193.    exit(2);
  194.   }
  195.   break;
  196.  case 'V':
  197.   printf("ping utility, iputils-ss%s\n", SNAPSHOT);
  198.   exit(0);
  199.  COMMON_OPTIONS
  200.   common_options(ch);
  201.   break;
  202.  default:
  203.   usage();
  204.  }
  205. }
  206. argc -= optind;
  207. argv += optind;
  209. if (argc == 0)
  210.  usage();
  211. if (argc > 1) {
  212.  if (options & F_RROUTE)
  213.   usage();
  214.  else if (options & F_TIMESTAMP) {
  215.   if (ts_type != IPOPT_TS_PRESPEC)
  216.    usage();
  217.   if (argc > 5)
  218.    usage();
  219.  } else {
  220.   if (argc > 10)
  221.    usage();
  222.   options |= F_SOURCEROUTE;
  223.  }
  224. }
  225. while (argc > 0) {
  226.  target = *argv;
  228.  bzero((char *)&whereto, sizeof(whereto));
  229.  whereto.sin_family = AF_INET;
  230.  if (inet_aton(target, &whereto.sin_addr) == 1) {
  231.   hostname = target;
  232.   if (argc == 1)
  233.    options |= F_NUMERIC;
  234.  } else {
  235.   hp = gethostbyname(target);
  236.   if (!hp) {
  237.    fprintf(stderr, "ping: unknown host %s\n", target);
  238.    exit(2);
  239.   }
  240.   memcpy(&whereto.sin_addr, hp->h_addr, 4);
  241.   strncpy(hnamebuf, hp->h_name, sizeof(hnamebuf) - 1);
  242.   hnamebuf[sizeof(hnamebuf) - 1] = 0;
  243.   hostname = hnamebuf;
  244.  }
  245.  if (argc > 1)
  246.   route[nroute++] = whereto.sin_addr.s_addr;
  247.  argc--;
  248.  argv++;
  249. }
  251. if (source.sin_addr.s_addr == 0) {
  252.  int alen;
  253.  struct sockaddr_in dst = whereto;
  254.  int probe_fd = socket(AF_INET, SOCK_DGRAM, 0);
  256.  if (probe_fd < 0) {
  257.   perror("socket" );
  258.   exit(2);
  259.  }
  260.  if (device) {
  261.   struct ifreq ifr;
  262.   memset(&ifr, 0, sizeof(ifr));
  263.   strncpy(ifr.ifr_name, device, IFNAMSIZ-1);
  264.   if (setsockopt(probe_fd, SOL_SOCKET, SO_BINDTODEVICE, device, strlen(device)+1) == -1) {
  265.    if (IN_MULTICAST(ntohl(dst.sin_addr.s_addr))) {
  266.     struct ip_mreqn imr;
  267.     if (ioctl(probe_fd, SIOCGIFINDEX, &ifr) < 0) {
  268.      fprintf(stderr, "ping: unknown iface %s\n", device);
  269.      exit(2);
  270.     }
  271.     memset(&imr, 0, sizeof(imr));
  272.     imr.imr_ifindex = ifr.ifr_ifindex;
  273.     if (setsockopt(probe_fd, SOL_IP, IP_MULTICAST_IF, &imr, sizeof(imr)) == -1) {
  274.      perror("ping: IP_MULTICAST_IF" );
  275.      exit(2);
  276.     }
  277.    }
  278.   }
  279.  }
  281.  if (settos &&
  282.      setsockopt(probe_fd, IPPROTO_IP, IP_TOS, (char *)&settos, sizeof(int)) < 0)
  283.   perror("Warning: error setting QOS sockopts" );
  285.  dst.sin_port = htons(1025);
  286.  if (nroute)
  287.   dst.sin_addr.s_addr = route[0];
  288.  if (connect(probe_fd, (struct sockaddr*)&dst, sizeof(dst)) == -1) {
  289.   if (errno == EACCES) {
  290.    if (broadcast_pings == 0) {
  291.     fprintf(stderr, "Do you want to ping broadcast? Then -b\n" );
  292.     exit(2);
  293.    }
  294.    fprintf(stderr, "WARNING: pinging broadcast address\n" );
  295.    if (setsockopt(probe_fd, SOL_SOCKET, SO_BROADCAST,
  296.            &broadcast_pings, sizeof(broadcast_pings)) < 0) {
  297.     perror ("can't set broadcasting" );
  298.     exit(2);
  299.    }
  300.    if (connect(probe_fd, (struct sockaddr*)&dst, sizeof(dst)) == -1) {
  301.     perror("connect" );
  302.     exit(2);
  303.    }
  304.   } else {
  305.    perror("connect" );
  306.    exit(2);
  307.   }
  308.  }
  309.  alen = sizeof(source);
  310.  if (getsockname(probe_fd, (struct sockaddr*)&source, &alen) == -1) {
  311.   perror("getsockname" );
  312.   exit(2);
  313.  }
  314.  source.sin_port = 0;
  315.  close(probe_fd);
  316. } while (0);
  318. if (whereto.sin_addr.s_addr == 0)
  319.  whereto.sin_addr.s_addr = source.sin_addr.s_addr;
  321. if (icmp_sock < 0) {
  322.  errno = socket_errno;
  323.  perror("ping: icmp open socket" );
  324.  exit(2);
  325. }
  327. if (device) {
  328.  struct ifreq ifr;
  330.  memset(&ifr, 0, sizeof(ifr));
  331.  strncpy(ifr.ifr_name, device, IFNAMSIZ-1);
  332.  if (ioctl(icmp_sock, SIOCGIFINDEX, &ifr) < 0) {
  333.   fprintf(stderr, "ping: unknown iface %s\n", device);
  334.   exit(2);
  335.  }
  336.  cmsg.ipi.ipi_ifindex = ifr.ifr_ifindex;
  337.  cmsg_len = sizeof(cmsg);
  338. }
  340. if (broadcast_pings || IN_MULTICAST(ntohl(whereto.sin_addr.s_addr))) {
  341.  if (uid) {
  342.   if (interval < 1000) {
  343.    fprintf(stderr, "ping: broadcast ping with too short interval.\n" );
  344.    exit(2);
  345.   }
  346.   if (pmtudisc >= 0 && pmtudisc != IP_PMTUDISC_DO) {
  347.    fprintf(stderr, "ping: broadcast ping does not fragment.\n" );
  348.    exit(2);
  349.   }
  350.  }
  351.  if (pmtudisc < 0)
  352.   pmtudisc = IP_PMTUDISC_DO;
  353. }
  355. if (pmtudisc >= 0) {
  356.  if (setsockopt(icmp_sock, SOL_IP, IP_MTU_DISCOVER, &pmtudisc, sizeof(pmtudisc)) == -1) {
  357.   perror("ping: IP_MTU_DISCOVER" );
  358.   exit(2);
  359.  }
  360. }
  362. if ((options&F_STRICTSOURCE) &&
  363.     bind(icmp_sock, (struct sockaddr*)&source, sizeof(source)) == -1) {
  364.  perror("bind" );
  365.  exit(2);
  366. }
  368. if (1) {
  369.  struct icmp_filter filt;
  370.  filt.data = ~((1<<ICMP_SOURCE_QUENCH)|
  371.         (1<<ICMP_DEST_UNREACH)|
  372.         (1<<ICMP_TIME_EXCEEDED)|
  373.         (1<<ICMP_PARAMETERPROB)|
  374.         (1<<ICMP_REDIRECT)|
  375.         (1<<ICMP_ECHOREPLY));
  376.  if (setsockopt(icmp_sock, SOL_RAW, ICMP_FILTER, (char*)&filt, sizeof(filt)) == -1)
  377.   perror("WARNING: setsockopt(ICMP_FILTER)" );
  378. }
  380. hold = 1;
  381. if (setsockopt(icmp_sock, SOL_IP, IP_RECVERR, (char *)&hold, sizeof(hold)))
  382.  fprintf(stderr, "WARNING: your kernel is veeery old. No problems.\n" );
  384. /* record route option */
  385. if (options & F_RROUTE) {
  386.         bzero(rspace, sizeof(rspace));
  387.  rspace[0] = IPOPT_NOP;
  388.  rspace[1+IPOPT_OPTVAL] = IPOPT_RR;
  389.  rspace[1+IPOPT_OLEN] = sizeof(rspace)-1;
  390.  rspace[1+IPOPT_OFFSET] = IPOPT_MINOFF;
  391.  optlen = 40;
  392.  if (setsockopt(icmp_sock, IPPROTO_IP, IP_OPTIONS, rspace, sizeof(rspace)) < 0) {
  393.   perror("ping: record route" );
  394.   exit(2);
  395.  }
  396. }
  397. if (options & F_TIMESTAMP) {
  398.         bzero(rspace, sizeof(rspace));
  399.  rspace[0] = IPOPT_TIMESTAMP;
  400.  rspace[1] = (ts_type==IPOPT_TS_TSONLY ? 40 : 36);
  401.  rspace[2] = 5;
  402.  rspace[3] = ts_type;
  403.  if (ts_type == IPOPT_TS_PRESPEC) {
  404.   int i;
  405.   rspace[1] = 4+nroute*8;
  406.   for (i=0; i<nroute; i++)
  407.    *(__u32*)&rspace[4+i*8] = route[i];
  408.  }
  409.  if (setsockopt(icmp_sock, IPPROTO_IP, IP_OPTIONS, rspace, rspace[1]) < 0) {
  410.   rspace[3] = 2;
  411.   if (setsockopt(icmp_sock, IPPROTO_IP, IP_OPTIONS, rspace, rspace[1]) < 0) {
  412.    perror("ping: ts option" );
  413.    exit(2);
  414.   }
  415.  }
  416.  optlen = 40;
  417. }
  418. if (options & F_SOURCEROUTE) {
  419.         int i;
  420.         bzero(rspace, sizeof(rspace));
  421.  rspace[0] = IPOPT_NOOP;
  422.  rspace[1+IPOPT_OPTVAL] = (options & F_SO_DONTROUTE) ? IPOPT_SSRR
  423.   : IPOPT_LSRR;
  424.  rspace[1+IPOPT_OLEN] = 3 + nroute*4;
  425.  rspace[1+IPOPT_OFFSET] = IPOPT_MINOFF;
  426.  for (i=0; i<nroute; i++)
  427.   *(__u32*)&rspace[4+i*4] = route[i];
  429.  if (setsockopt(icmp_sock, IPPROTO_IP, IP_OPTIONS, rspace, 4 + nroute*4) < 0) {
  430.   perror("ping: record route" );
  431.   exit(2);
  432.  }
  433.  optlen = 40;
  434. }
  436. /* Estimate memory eaten by single packet. It is rough estimate.
  437.  * Actually, for small datalen's it depends on kernel side a lot. */
  438. hold = datalen + 8;
  439. hold += ((hold+511)/512)*(optlen + 20 + 16 + 64 + 160);
  440. sock_setbufs(icmp_sock, hold);
  442. if (broadcast_pings) {
  443.  if (setsockopt(icmp_sock, SOL_SOCKET, SO_BROADCAST,
  444.          &broadcast_pings, sizeof(broadcast_pings)) < 0) {
  445.   perror ("ping: can't set broadcasting" );
  446.   exit(2);
  447.  }
  448.         }
  450. if (options & F_NOLOOP) {
  451.  int loop = 0;
  452.  if (setsockopt(icmp_sock, IPPROTO_IP, IP_MULTICAST_LOOP,
  453.       &loop, 1) == -1) {
  454.   perror ("ping: can't disable multicast loopback" );
  455.   exit(2);
  456.  }
  457. }
  458. if (options & F_TTL) {
  459.  int ittl = ttl;
  460.  if (setsockopt(icmp_sock, IPPROTO_IP, IP_MULTICAST_TTL,
  461.       &ttl, 1) == -1) {
  462.   perror ("ping: can't set multicast time-to-live" );
  463.   exit(2);
  464.  }
  465.  if (setsockopt(icmp_sock, IPPROTO_IP, IP_TTL,
  466.       &ittl, sizeof(ittl)) == -1) {
  467.   perror ("ping: can't set unicast time-to-live" );
  468.   exit(2);
  469.  }
  470. }
  472. if (datalen > 0xFFFF - 8 - optlen - 20) {
  473.  if (uid || datalen > sizeof(outpack)-8) {
  474.   fprintf(stderr, "Error: packet size %d is too large. Maximum is %d\n", datalen, 0xFFFF-8-20-optlen);
  475.   exit(2);
  476.  }
  477.  /* Allow small oversize to root yet. It will cause EMSGSIZE. */
  478.  fprintf(stderr, "WARNING: packet size %d is too large. Maximum is %d\n", datalen, 0xFFFF-8-20-optlen);
  479. }
  481. if (datalen >= sizeof(struct timeval)) /* can we time transfer */
  482.  timing = 1;
  483. packlen = datalen + MAXIPLEN + MAXICMPLEN;
  484. if (!(packet = (u_char *)malloc((u_int)packlen))) {
  485.  fprintf(stderr, "ping: out of memory.\n" );
  486.  exit(2);
  487. }
  489. printf("PING %s (%s) ", hostname, inet_ntoa(whereto.sin_addr));
  490. if (device || (options&F_STRICTSOURCE))
  491.  printf("from %s %s: ", inet_ntoa(source.sin_addr), device ?: "" );
  492. printf("%d(%d) bytes of data.\n", datalen, datalen+8+optlen+20);
  494. setup(icmp_sock);
  496. main_loop(icmp_sock, packet, packlen);
  497. }
  500. int receive_error_msg()
  501. {
  502. int res;
  503. char cbuf[512];
  504. struct iovec  iov;
  505. struct msghdr msg;
  506. struct cmsghdr *cmsg;
  507. struct sock_extended_err *e;
  508. struct icmphdr icmph;
  509. struct sockaddr_in target;
  510. int net_errors = 0;
  511. int local_errors = 0;
  512. int saved_errno = errno;
  514. iov.iov_base = &icmph;
  515. iov.iov_len = sizeof(icmph);
  516. msg.msg_name = (void*)⌖
  517. msg.msg_namelen = sizeof(target);
  518. msg.msg_iov = &iov;
  519. msg.msg_iovlen = 1;
  520. msg.msg_flags = 0;
  521. msg.msg_control = cbuf;
  522. msg.msg_controllen = sizeof(cbuf);
  524. res = recvmsg(icmp_sock, &msg, MSG_ERRQUEUE|MSG_DONTWAIT);
  525. if (res < 0)
  526.  goto out;
  528. e = NULL;
  529. for (cmsg = CMSG_FIRSTHDR(&msg); cmsg; cmsg = CMSG_NXTHDR(&msg, cmsg)) {
  530.  if (cmsg->cmsg_level == SOL_IP) {
  531.   if (cmsg->cmsg_type == IP_RECVERR)
  532.    e = (struct sock_extended_err *)CMSG_DATA(cmsg);
  533.  }
  534. }
  535. if (e == NULL)
  536.  abort();
  538. if (e->ee_origin == SO_EE_ORIGIN_LOCAL) {
  539.  local_errors++;
  540.  if (options & F_QUIET)
  541.   goto out;
  542.  if (options & F_FLOOD)
  543.   write(STDOUT_FILENO, "E", 1);
  544.  else if (e->ee_errno != EMSGSIZE)
  545.   fprintf(stderr, "ping: local error: %s\n", strerror(e->ee_errno));
  546.  else
  547.   fprintf(stderr, "ping: local error: Message too long, mtu=%u\n", e->ee_info);
  548.  nerrors++;
  549. } else if (e->ee_origin == SO_EE_ORIGIN_ICMP) {
  550.  struct sockaddr_in *sin = (struct sockaddr_in*)(e+1);
  552.  if (res < sizeof(icmph) ||
  553.      target.sin_addr.s_addr != whereto.sin_addr.s_addr ||
  554.      icmph.type != ICMP_ECHO ||
  555.      icmph.un.echo.id != ident) {
  556.   /* Not our error, not an error at all. Clear. */
  557.   saved_errno = 0;
  558.   goto out;
  559.  }
  561.  acknowledge(ntohs(icmph.un.echo.sequence));
  563.  if (!working_recverr) {
  564.   struct icmp_filter filt;
  565.   working_recverr = 1;
  566.   /* OK, it works. Add stronger filter. */
  567.   filt.data = ~((1<<ICMP_SOURCE_QUENCH)|
  568.          (1<<ICMP_REDIRECT)|
  569.          (1<<ICMP_ECHOREPLY));
  570.   if (setsockopt(icmp_sock, SOL_RAW, ICMP_FILTER, (char*)&filt, sizeof(filt)) == -1)
  571.    perror("\rWARNING: setsockopt(ICMP_FILTER)" );
  572.  }
  574.  net_errors++;
  575.  nerrors++;
  576.  if (options & F_QUIET)
  577.   goto out;
  578.  if (options & F_FLOOD) {
  579.   write(STDOUT_FILENO, "\bE", 2);
  580.  } else {
  581.   printf("From %s icmp_seq=%u ", pr_addr(sin->sin_addr.s_addr), ntohs(icmph.un.echo.sequence));
  582.   pr_icmph(e->ee_type, e->ee_code, e->ee_info, NULL);
  583.   fflush(stdout);
  584.  }
  585. }
  587. out:
  588. errno = saved_errno;
  589. return net_errors ? : -local_errors;
  590. }
  592. /*
  593. * pinger --
  594. *  Compose and transmit an ICMP ECHO REQUEST packet.  The IP packet
  595. * will be added on by the kernel.  The ID field is our UNIX process ID,
  596. * and the sequence number is an ascending integer.  The first 8 bytes
  597. * of the data portion are used to hold a UNIX "timeval" struct in VAX
  598. * byte-order, to compute the round-trip time.
  599. */
  600. int send_probe()
  601. {
  602. struct icmphdr *icp;
  603. int cc;
  604. int i;
  606. icp = (struct icmphdr *)outpack;
  607. icp->type = ICMP_ECHO;
  608. icp->code = 0;
  609. icp->checksum = 0;
  610. icp->un.echo.sequence = htons(ntransmitted+1);
  611. icp->un.echo.id = ident;   /* ID */
  613. CLR((ntransmitted+1) % mx_dup_ck);
  615. if (timing) {
  616.  if (options&F_LATENCY) {
  617.   static volatile int fake_fucked_egcs = sizeof(struct timeval);
  618.   struct timeval tmp_tv;
  619.   gettimeofday(&tmp_tv, NULL);
  620.   /* egcs is crap or glibc is crap, but memcpy  
  621.      does not copy anything, if len is constant! */
  622.   memcpy(icp+1, &tmp_tv, fake_fucked_egcs);
  623.  } else {
  624.   memset(icp+1, 0, sizeof(struct timeval));
  625.  }
  626. }
  628. cc = datalen + 8;   /* skips ICMP portion */
  630. /* compute ICMP checksum here */
  631. icp->checksum = in_cksum((u_short *)icp, cc, 0);
  633. if (timing && !(options&F_LATENCY)) {
  634.  static volatile int fake_fucked_egcs = sizeof(struct timeval);
  635.         struct timeval tmp_tv;
  636.  gettimeofday(&tmp_tv, NULL);
  637.  /* egcs is crap or glibc is crap, but memcpy  
  638.     does not copy anything, if len is constant! */
  639.  memcpy(icp+1, &tmp_tv, fake_fucked_egcs);
  640.  icp->checksum = in_cksum((u_short *)(icp+1), fake_fucked_egcs, ~icp->checksum);
  641. }
  643.         do {
  644.  static struct iovec iov = {outpack, 0};
  645.  static struct msghdr m = { &whereto, sizeof(whereto),
  646.         &iov, 1, &cmsg, 0, 0 };
  647.  m.msg_controllen = cmsg_len;
  648.  iov.iov_len = cc;
  650.  i = sendmsg(icmp_sock, &m, confirm);
  651.  confirm = 0;
  652. } while (0);
  654. return (cc == i ? 0 : i);
  655. }
  657. /*
  658. * parse_reply --
  659. * Print out the packet, if it came from us.  This logic is necessary
  660. * because ALL readers of the ICMP socket get a copy of ALL ICMP packets
  661. * which arrive ('tis only fair).  This permits multiple copies of this
  662. * program to be run without having intermingled output (or statistics!).
  663. */
  664. int
  665. parse_reply(struct msghdr *msg, int cc, void *addr, struct timeval *tv)
  666. {
  667. struct sockaddr_in *from = addr;
  668. __u8 *buf = msg->msg_iov->iov_base;
  669. struct icmphdr *icp;
  670. struct iphdr *ip;
  671. int hlen;
  672. int csfailed;
  674. /* Check the IP header */
  675. ip = (struct iphdr *)buf;
  676. hlen = ip->ihl*4;
  677. if (cc < hlen + 8 || ip->ihl < 5) {
  678.  if (options & F_VERBOSE)
  679.   fprintf(stderr, "ping: packet too short (%d bytes) from %s\n", cc,
  680.    pr_addr(from->sin_addr.s_addr));
  681.  return 1;
  682. }
  684. /* Now the ICMP part */
  685. cc -= hlen;
  686. icp = (struct icmphdr *)(buf + hlen);
  687. csfailed = in_cksum((u_short *)icp, cc, 0);
  689. if (icp->type == ICMP_ECHOREPLY) {
  690.  if (icp->un.echo.id != ident)
  691.   return 1;   /* 'Twas not our ECHO */
  692.  if (gather_statistics((__u8*)(icp+1), cc,
  693.          ntohs(icp->un.echo.sequence),
  694.          ip->ttl, 0, tv, pr_addr(from->sin_addr.s_addr)))
  695.   return 0;
  696. } else {
  697.  /* We fall here when a redirect or source quench arrived.
  698.   * Also this branch processes icmp errors, when IP_RECVERR
  699.   * is broken. */
  700.   
  701.         switch (icp->type) {
  702.  case ICMP_ECHO:
  703.   /* MUST NOT */
  704.   return 1;
  705.  case ICMP_SOURCE_QUENCH:
  706.  case ICMP_REDIRECT:
  707.  case ICMP_DEST_UNREACH:
  708.  case ICMP_TIME_EXCEEDED:
  709.  case ICMP_PARAMETERPROB:
  710.   {
  711.    struct iphdr * iph = (struct  iphdr *)(&icp[1]);
  712.    struct icmphdr *icp1 = (struct icmphdr*)((unsigned char *)iph + iph->ihl*4);
  713.    int error_pkt;
  714.    if (cc < 8+sizeof(struct iphdr)+8 ||
  715.        cc < 8+iph->ihl*4+8)
  716.     return 1;
  717.    if (icp1->type != ICMP_ECHO ||
  718.        iph->daddr != whereto.sin_addr.s_addr ||
  719.        icp1->un.echo.id != ident)
  720.     return 1;
  721.    error_pkt = (icp->type != ICMP_REDIRECT &&
  722.          icp->type != ICMP_SOURCE_QUENCH);
  723.    if (error_pkt) {
  724.     acknowledge(ntohs(icp1->un.echo.sequence));
  725.     if (working_recverr) {
  726.      return 0;
  727.     } else {
  728.      static int once;
  729.      /* Sigh, IP_RECVERR for raw socket
  730.       * was broken until 2.4.9. So, we ignore
  731.       * the first error and warn on the second.
  732.       */
  733.      if (once++ == 1)
  734.       fprintf(stderr, "\rWARNING: kernel is not very fresh, upgrade is recommended.\n" );
  735.      if (once == 1)
  736.       return 0;
  737.     }
  738.    }
  739.    nerrors+=error_pkt;
  740.    if (options&F_QUIET)
  741.     return !error_pkt;
  742.    if (options & F_FLOOD) {
  743.     if (error_pkt)
  744.      write(STDOUT_FILENO, "\bE", 2);
  745.     return !error_pkt;
  746.    }
  747.    printf("From %s: icmp_seq=%u ",
  748.           pr_addr(from->sin_addr.s_addr),
  749.           ntohs(icp1->un.echo.sequence));
  750.    if (csfailed)
  751.     printf("(BAD CHECKSUM)" );
  752.    pr_icmph(icp->type, icp->code, ntohl(icp->un.gateway), icp);
  753.    return !error_pkt;
  754.   }
  755.         default:
  756.   /* MUST NOT */
  757.   break;
  758.  }
  759.  if ((options & F_FLOOD) && !(options & (F_VERBOSE|F_QUIET))) {
  760.   if (!csfailed)
  761.    write(STDOUT_FILENO, "!E", 2);
  762.   else
  763.    write(STDOUT_FILENO, "!EC", 3);
  764.   return 0;
  765.  }
  766.  if (!(options & F_VERBOSE) || uid)
  767.   return 0;
  768.  printf("From %s: ", pr_addr(from->sin_addr.s_addr));
  769.  if (csfailed) {
  770.   printf("(BAD CHECKSUM)\n" );
  771.   return 0;
  772.  }
  773.  pr_icmph(icp->type, icp->code, ntohl(icp->un.gateway), icp);
  774.  return 0;
  775. }
  777. if (!(options & F_FLOOD)) {
  778.  pr_options(buf + sizeof(struct iphdr), hlen);
  780.  if (options & F_AUDIBLE)
  781.   putchar('\a');
  782.  putchar('\n');
  783.  fflush(stdout);
  784. }
  785. return 0;
  786. }
  788. u_short
  789. in_cksum(const u_short *addr, register int len, u_short csum)
  790. {
  791. register int nleft = len;
  792. const u_short *w = addr;
  793. register u_short answer;
  794. register int sum = csum;
  796. /*
  797.  *  Our algorithm is simple, using a 32 bit accumulator (sum),
  798.  *  we add sequential 16 bit words to it, and at the end, fold
  799.  *  back all the carry bits from the top 16 bits into the lower
  800.  *  16 bits.
  801.  */
  802. while (nleft > 1)  {
  803.  sum += *w++;
  804.  nleft -= 2;
  805. }
  807. /* mop up an odd byte, if necessary */
  808. if (nleft == 1)
  809.  sum += htons(*(u_char *)w << 8);
  811. /*
  812.  * add back carry outs from top 16 bits to low 16 bits
  813.  */
  814. sum = (sum >> 16) + (sum & 0xffff); /* add hi 16 to low 16 */
  815. sum += (sum >> 16);   /* add carry */
  816. answer = ~sum;    /* truncate to 16 bits */
  817. return (answer);
  818. }
  820. /*
  821. * pr_icmph --
  822. * Print a descriptive string about an ICMP header.
  823. */
  824. void pr_icmph(__u8 type, __u8 code, __u32 info, struct icmphdr *icp)
  825. {
  826. switch(type) {
  827. case ICMP_ECHOREPLY:
  828.  printf("Echo Reply\n" );
  829.  /* XXX ID + Seq + Data */
  830.  break;
  831. case ICMP_DEST_UNREACH:
  832.  switch(code) {
  833.  case ICMP_NET_UNREACH:
  834.   printf("Destination Net Unreachable\n" );
  835.   break;
  836.  case ICMP_HOST_UNREACH:
  837.   printf("Destination Host Unreachable\n" );
  838.   break;
  839.  case ICMP_PROT_UNREACH:
  840.   printf("Destination Protocol Unreachable\n" );
  841.   break;
  842.  case ICMP_PORT_UNREACH:
  843.   printf("Destination Port Unreachable\n" );
  844.   break;
  845.  case ICMP_FRAG_NEEDED:
  846.   printf("Frag needed and DF set (mtu = %u)\n", info);
  847.   break;
  848.  case ICMP_SR_FAILED:
  849.   printf("Source Route Failed\n" );
  850.   break;
  851.  case ICMP_PKT_FILTERED:
  852.   printf("Packet filtered\n" );
  853.   break;
  854.  default:
  855.   printf("Dest Unreachable, Bad Code: %d\n", code);
  856.   break;
  857.  }
  858.  if (icp && (options & F_VERBOSE))
  859.   pr_iph((struct iphdr*)(icp + 1));
  860.  break;
  861. case ICMP_SOURCE_QUENCH:
  862.  printf("Source Quench\n" );
  863.  if (icp && (options & F_VERBOSE))
  864.   pr_iph((struct iphdr*)(icp + 1));
  865.  break;
  866. case ICMP_REDIRECT:
  867.  switch(code) {
  868.  case ICMP_REDIR_NET:
  869.   printf("Redirect Network" );
  870.   break;
  871.  case ICMP_REDIR_HOST:
  872.   printf("Redirect Host" );
  873.   break;
  874.  case ICMP_REDIR_NETTOS:
  875.   printf("Redirect Type of Service and Network" );
  876.   break;
  877.  case ICMP_REDIR_HOSTTOS:
  878.   printf("Redirect Type of Service and Host" );
  879.   break;
  880.  default:
  881.   printf("Redirect, Bad Code: %d", code);
  882.   break;
  883.  }
  884.  if (icp)
  885.   printf("(New nexthop: %s)\n", pr_addr(icp->un.gateway));
  886.  if (icp && (options & F_VERBOSE))
  887.   pr_iph((struct iphdr*)(icp + 1));
  888.  break;
  889. case ICMP_ECHO:
  890.  printf("Echo Request\n" );
  891.  /* XXX ID + Seq + Data */
  892.  break;
  893. case ICMP_TIME_EXCEEDED:
  894.  switch(code) {
  895.  case ICMP_EXC_TTL:
  896.   printf("Time to live exceeded\n" );
  897.   break;
  898.  case ICMP_EXC_FRAGTIME:
  899.   printf("Frag reassembly time exceeded\n" );
  900.   break;
  901.  default:
  902.   printf("Time exceeded, Bad Code: %d\n", code);
  903.   break;
  904.  }
  905.  if (icp && (options & F_VERBOSE))
  906.   pr_iph((struct iphdr*)(icp + 1));
  907.  break;
  908. case ICMP_PARAMETERPROB:
  909.  printf("Parameter problem: pointer = %u\n", icp ? (ntohl(icp->un.gateway)>>24) : info);
  910.  if (icp && (options & F_VERBOSE))
  911.   pr_iph((struct iphdr*)(icp + 1));
  912.  break;
  913. case ICMP_TIMESTAMP:
  914.  printf("Timestamp\n" );
  915.  /* XXX ID + Seq + 3 timestamps */
  916.  break;
  917. case ICMP_TIMESTAMPREPLY:
  918.  printf("Timestamp Reply\n" );
  919.  /* XXX ID + Seq + 3 timestamps */
  920.  break;
  921. case ICMP_INFO_REQUEST:
  922.  printf("Information Request\n" );
  923.  /* XXX ID + Seq */
  924.  break;
  925. case ICMP_INFO_REPLY:
  926.  printf("Information Reply\n" );
  927.  /* XXX ID + Seq */
  928.  break;
  929. #ifdef ICMP_MASKREQ
  930. case ICMP_MASKREQ:
  931.  printf("Address Mask Request\n" );
  932.  break;
  933. #endif
  934. #ifdef ICMP_MASKREPLY
  935. case ICMP_MASKREPLY:
  936.  printf("Address Mask Reply\n" );
  937.  break;
  938. #endif
  939. default:
  940.  printf("Bad ICMP type: %d\n", type);
  941. }
  942. }
  944. void pr_options(unsigned char * cp, int hlen)
  945. {
  946. int i, j;
  947. int optlen, totlen;
  948. unsigned char * optptr;
  949. static int old_rrlen;
  950. static char old_rr[MAX_IPOPTLEN];
  952. totlen = hlen-sizeof(struct iphdr);
  953. optptr = cp;
  955. while (totlen > 0) {
  956.  if (*optptr == IPOPT_EOL)
  957.   break;
  958.  if (*optptr == IPOPT_NOP) {
  959.   totlen--;
  960.   optptr++;
  961.   printf("\nNOP" );
  962.   continue;
  963.  }
  964.  cp = optptr;
  965.  optlen = optptr[1];
  966.  if (optlen < 2 || optlen > totlen)
  967.   break;
  969.  switch (*cp) {
  970.  case IPOPT_SSRR:
  971.  case IPOPT_LSRR:
  972.   printf("\n%cSRR: ", *cp==IPOPT_SSRR ? 'S' : 'L');
  973.   j = *++cp;
  974.   i = *++cp;
  975.   i -= 4;
  976.   cp++;
  977.   if (j > IPOPT_MINOFF) {
  978.    for (;;) {
  979.     __u32 address;
  980.     memcpy(&address, cp, 4);
  981.     cp += 4;
  982.     if (address == 0)
  983.      printf("\t0.0.0.0" );
  984.     else
  985.      printf("\t%s", pr_addr(address));
  986.     j -= 4;
  987.     putchar('\n');
  988.     if (j <= IPOPT_MINOFF)
  989.      break;
  990.    }
  991.   }
  992.   break;
  993.  case IPOPT_RR:
  994.   j = *++cp;  /* get length */
  995.   i = *++cp;  /* and pointer */
  996.   if (i > j)
  997.    i = j;
  998.   i -= IPOPT_MINOFF;
  999.   if (i <= 0)
  1000.    continue;
  1001.   if (i == old_rrlen
  1002.       && !bcmp((char *)cp, old_rr, i)
  1003.       && !(options & F_FLOOD)) {
  1004.    printf("\t(same route)" );
  1005.    i = ((i + 3) / 4) * 4;
  1006.    cp += i;
  1007.    break;
  1008.   }
  1009.   old_rrlen = i;
  1010.   bcopy((char *)cp, old_rr, i);
  1011.   printf("\nRR: " );
  1012.   cp++;
  1013.   for (;;) {
  1014.    __u32 address;
  1015.    memcpy(&address, cp, 4);
  1016.    cp += 4;
  1017.    if (address == 0)
  1018.     printf("\t0.0.0.0" );
  1019.    else
  1020.     printf("\t%s", pr_addr(address));
  1021.    i -= 4;
  1022.    putchar('\n');
  1023.    if (i <= 0)
  1024.     break;
  1025.   }
  1026.   break;
  1027.  case IPOPT_TS:
  1028.  {
  1029.   int stdtime = 0, nonstdtime = 0;
  1030.   __u8 flags;
  1031.   j = *++cp;  /* get length */
  1032.   i = *++cp;  /* and pointer */
  1033.   if (i > j)
  1034.    i = j;
  1035.   i -= 5;
  1036.   if (i <= 0)
  1037.    continue;
  1038.   flags = *++cp;
  1039.   printf("\nTS: " );
  1040.   cp++;
  1041.   for (;;) {
  1042.    long l;
  1044.    if ((flags&0xF) != IPOPT_TS_TSONLY) {
  1045.     __u32 address;
  1046.     memcpy(&address, cp, 4);
  1047.     cp += 4;
  1048.     if (address == 0)
  1049.      printf("\t0.0.0.0" );
  1050.     else
  1051.      printf("\t%s", pr_addr(address));
  1052.     i -= 4;
  1053.     if (i <= 0)
  1054.      break;
  1055.    }
  1056.    l = *cp++;
  1057.    l = (l<<8) + *cp++;
  1058.    l = (l<<8) + *cp++;
  1059.    l = (l<<8) + *cp++;
  1061.    if  (l & 0x80000000) {
  1062.     if (nonstdtime==0)
  1063.      printf("\t%ld absolute not-standard", l&0x7fffffff);
  1064.     else
  1065.      printf("\t%ld not-standard", (l&0x7fffffff) - nonstdtime);
  1066.     nonstdtime = l&0x7fffffff;
  1067.    } else {
  1068.     if (stdtime==0)
  1069.      printf("\t%ld absolute", l);
  1070.     else
  1071.      printf("\t%ld", l - stdtime);
  1072.     stdtime = l;
  1073.    }
  1074.    i -= 4;
  1075.    putchar('\n');
  1076.    if (i <= 0)
  1077.     break;
  1078.   }
  1079.   if (flags>>4)
  1080.    printf("Unrecorded hops: %d\n", flags>>4);
  1081.   break;
  1082.  }
  1083.  default:
  1084.   printf("\nunknown option %x", *cp);
  1085.   break;
  1086.  }
  1087.  totlen -= optlen;
  1088.  optptr += optlen;
  1089. }
  1090. }
  1093. /*
  1094. * pr_iph --
  1095. * Print an IP header with options.
  1096. */
  1097. void pr_iph(struct iphdr *ip)
  1098. {
  1099. int hlen;
  1100. u_char *cp;
  1102. hlen = ip->ihl << 2;
  1103. cp = (u_char *)ip + 20;  /* point to options */
  1105. printf("Vr HL TOS  Len   ID Flg  off TTL Pro  cks      Src      Dst Data\n" );
  1106. printf(" %1x  %1x  %02x %04x %04x",
  1107.        ip->version, ip->ihl, ip->tos, ip->tot_len, ip->id);
  1108. printf("   %1x %04x", ((ip->frag_off) & 0xe000) >> 13,
  1109.        (ip->frag_off) & 0x1fff);
  1110. printf("  %02x  %02x %04x", ip->ttl, ip->protocol, ip->check);
  1111. printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->saddr));
  1112. printf(" %s ", inet_ntoa(*(struct in_addr *)&ip->daddr));
  1113. printf("\n" );
  1114. pr_options(cp, hlen);
  1115. }
  1117. /*
  1118. * pr_addr --
  1119. * Return an ascii host address as a dotted quad and optionally with
  1120. * a hostname.
  1121. */
  1122. char *
  1123. pr_addr(__u32 addr)
  1124. {
  1125. struct hostent *hp;
  1126. static char buf[4096];
  1128. if ((options & F_NUMERIC) ||
  1129.     !(hp = gethostbyaddr((char *)&addr, 4, AF_INET)))
  1130.  sprintf(buf, "%s", inet_ntoa(*(struct in_addr *)&addr));
  1131. else
  1132.  snprintf(buf, sizeof(buf), "%s (%s)", hp->h_name,
  1133.    inet_ntoa(*(struct in_addr *)&addr));
  1134. return(buf);
  1135. }
  1138. /* Set Type of Service (TOS) and other Quality of Service relating bits */
  1139. int parsetos(char *str)
  1140. {
  1141.         const char *cp;
  1142.         int tos;
  1143.         char *ep;
  1145.         /* handle both hex and decimal values */
  1146.         if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X')) {
  1147.  cp = str + 2;
  1148.  tos = (int)strtol(cp, &ep, 16);
  1149.         } else
  1150.                 tos = (int)strtol(str, &ep, 10);
  1152.         /* doesn't look like decimal or hex, eh? */
  1153.         if (*ep != '\0') {
  1154.          fprintf(stderr, "ping: \"%s\" bad value for TOS\n", str);
  1155.          exit(2);
  1156.         }
  1158.         if (tos > TOS_MAX) {
  1159.          fprintf(stderr, "ping: the decimal value of TOS bits must be 0-254 (or zero)\n" );
  1160.          exit(2);
  1161.         }
  1162. return(tos);
  1163. }
  1165. #include <linux/filter.h>
  1167. void install_filter(void)
  1168. {
  1169. static int once;
  1170. static struct sock_filter insns[] = {
  1171.  BPF_STMT(BPF_LDX|BPF_B|BPF_MSH, 0), /* Skip IP header. F..g BSD... Look into ping6. */
  1172.  BPF_STMT(BPF_LD|BPF_H|BPF_IND, 4), /* Load icmp echo ident */
  1173.  BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, 0xAAAA, 0, 1), /* Ours? */
  1174.  BPF_STMT(BPF_RET|BPF_K, ~0U), /* Yes, it passes. */
  1175.  BPF_STMT(BPF_LD|BPF_B|BPF_IND, 0), /* Load icmp type */
  1176.  BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, ICMP_ECHOREPLY, 1, 0), /* Echo? */
  1177.  BPF_STMT(BPF_RET|BPF_K, 0xFFFFFFF), /* No. It passes. */
  1178.  BPF_STMT(BPF_RET|BPF_K, 0) /* Echo with wrong ident. Reject. */
  1179. };
  1180. static struct sock_fprog filter = {
  1181.  sizeof insns / sizeof(insns[0]),
  1182.  insns
  1183. };
  1185. if (once)
  1186.  return;
  1187. once = 1;
  1189. /* Patch bpflet for current identifier. */
  1190. insns[2] = (struct sock_filter)BPF_JUMP(BPF_JMP|BPF_JEQ|BPF_K, __constant_htons(ident), 0, 1);
  1192. if (setsockopt(icmp_sock, SOL_SOCKET, SO_ATTACH_FILTER, &filter, sizeof(filter)))
  1193.  perror("WARNING: failed to install socket filter\n" );
  1194. }
  1197. void usage(void)
  1198. {
  1199. fprintf(stderr,
  1200. "Usage: ping [-LRUbdfnqrvVaA] [-c count] [-i interval] [-w deadline]\n"
  1201. "            [-p pattern] [-s packetsize] [-t ttl] [-I interface or address]\n"
  1202. "            [-M mtu discovery hint] [-S sndbuf]\n"
  1203. "            [ -T timestamp option ] [ -Q tos ] [hop1 ...] destination\n" );
  1204. exit(2);
  1205. }


 
ftp://ftp.inr.ac.ru/ip-routing/
Ou apt-get source iputils-ping quand on a un système décent... oups.


Message édité par Jar Jar le 28-12-2002 à 00:02:55

---------------
« No question is too silly to ask, but, of course, some are too silly to answer. » -- Perl book
Reply

Marsh Posté le 28-12-2002 à 05:15:00    

merci pour la souce jarjar :)
pour le apt-get source ça marche avec toutes les distros ou c'est seulement pour deb?


---------------
http://www.core-tx.com
Reply

Marsh Posté le 28-12-2002 à 09:34:58    

de toutes façon tu peux avoir toutes les sources de tout les progs GPL de tes distro linux donc ça doit pas être bien dur à trouver ...  ;)


---------------
-@- When code matters more than commercials -@-
Reply

Marsh Posté le 28-12-2002 à 09:58:24    

Yep.
Je viens de telecharger 1.4Go de sources sur RedHat :o) :) :o)


---------------
FAQ fclc++ - FAQ C++ - C++ FAQ Lite
Reply

Marsh Posté le 28-12-2002 à 13:34:12    

Sky99 a écrit :

pour le apt-get source ça marche avec toutes les distros ou c'est seulement pour deb?

C'est la syntaxe Debian, mais j'imagine que Mandrake et Redhat ont des équivalents.


---------------
« No question is too silly to ask, but, of course, some are too silly to answer. » -- Perl book
Reply

Marsh Posté le    

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed