MSDN中Ping命令源代码

/******************************************************************************\
* ping.c - Simple ping utility using SOCK_RAW
* 
*        This is a part of the Microsoft Source Code Samples.
*        Copyright 1996-1997 Microsoft Corporation.
*        All rights reserved.
*        This source code is only intended as a supplement to
*        Microsoft Development Tools and/or WinHelp documentation.
*        See these sources for detailed information regarding the
*        Microsoft samples programs.
\******************************************************************************/

#pragma pack(4)

#define WIN32_LEAN_AND_MEAN
#include <winsock2.h>
#include <stdio.h>
#include <stdlib.h>

#define ICMP_ECHO 8
#define ICMP_ECHOREPLY 0

#define ICMP_MIN 8 // minimum 8 byte icmp packet (just header)

/* The IP header */
typedef struct iphdr {
         unsigned int h_len:4;           // length of the header
         unsigned int version:4;         // Version of IP
         unsigned char tos;              // Type of service
         unsigned short total_len;       // total length of the packet
         unsigned short ident;           // unique identifier
         unsigned short frag_and_flags; // flags
         unsigned char   ttl; 
         unsigned char proto;            // protocol (TCP, UDP etc)
         unsigned short checksum;        // IP checksum

         unsigned int sourceIP;
         unsigned int destIP;

}IpHeader;

//
// ICMP header
//
typedef struct _ihdr {
   BYTE i_type;
   BYTE i_code; /* type sub code */
   USHORT i_cksum;
   USHORT i_id;
   USHORT i_seq;
   /* This is not the std header, but we reserve space for time */
   ULONG timestamp;
}IcmpHeader;

#define STATUS_FAILED 0xFFFF
#define DEF_PACKET_SIZE 32
#define MAX_PACKET 1024

#define xmalloc(s) HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,(s))
#define xfree(p)    HeapFree (GetProcessHeap(),0,(p))

void fill_icmp_data(char *, int);
USHORT checksum(USHORT *, int);
void decode_resp(char *,int ,struct sockaddr_in *);

void Usage(char *progname){
  
   fprintf(stderr,"Usage:\n");
   fprintf(stderr,"%s <host> [data_size]\n",progname);
   fprintf(stderr,"datasize can be up to 1Kb\n");
   ExitProcess(STATUS_FAILED);

}
int main(int argc, char **argv){

   WSADATA wsaData;
   SOCKET sockRaw;
   struct sockaddr_in dest,from;
   struct hostent * hp;
   int bread,datasize;
   int fromlen = sizeof(from);
   int timeout = 1000;
   char *dest_ip;
   char *icmp_data;
   char *recvbuf;
   unsigned int addr=0;
   USHORT seq_no = 0;

   if (WSAStartup(MAKEWORD(2,1),&wsaData) != 0){
         fprintf(stderr,"WSAStartup failed: %d\n",GetLastError());
         ExitProcess(STATUS_FAILED);
   }

   if (argc <2 ) {
         Usage(argv[0]);
   }
   sockRaw = WSASocket (AF_INET,
                                            SOCK_RAW,
                                            IPPROTO_ICMP,
                                            NULL, 0,0);
  
   if (sockRaw == INVALID_SOCKET) {
         fprintf(stderr,"WSASocket() failed: %d\n",WSAGetLastError());
         ExitProcess(STATUS_FAILED);
   }
   bread = setsockopt(sockRaw,SOL_SOCKET,SO_RCVTIMEO,(char*)&timeout,
                                           sizeof(timeout));
   if(bread == SOCKET_ERROR) {
           fprintf(stderr,"failed to set recv timeout: %d\n",WSAGetLastError());
         ExitProcess(STATUS_FAILED);
   }
   timeout = 1000;
   bread = setsockopt(sockRaw,SOL_SOCKET,SO_SNDTIMEO,(char*)&timeout,
                                           sizeof(timeout));
   if(bread == SOCKET_ERROR) {
           fprintf(stderr,"failed to set send timeout: %d\n",WSAGetLastError());
         ExitProcess(STATUS_FAILED);
   }
   memset(&dest,0,sizeof(dest));

   hp = gethostbyname(argv[1]);

   if (!hp){
         addr = inet_addr(argv[1]);
   }
   if ((!hp)   && (addr == INADDR_NONE) ) {
         fprintf(stderr,"Unable to resolve %s\n",argv[1]);
         ExitProcess(STATUS_FAILED);
   }

   if (hp != NULL)
           memcpy(&(dest.sin_addr),hp->h_addr,hp->h_length);
   else
           dest.sin_addr.s_addr = addr;

   if (hp)
           dest.sin_family = hp->h_addrtype;
   else
           dest.sin_family = AF_INET;

   dest_ip = inet_ntoa(dest.sin_addr);

   if (argc >2) {
         datasize = atoi(argv[2]);
         if (datasize == 0)
           datasize = DEF_PACKET_SIZE;

   }
   else
           datasize = DEF_PACKET_SIZE;
        
   datasize += sizeof(IcmpHeader);  

   icmp_data = xmalloc(MAX_PACKET);
   recvbuf = xmalloc(MAX_PACKET);

   if (!icmp_data) {
         fprintf(stderr,"HeapAlloc failed %d\n",GetLastError());
         ExitProcess(STATUS_FAILED);
   }
  

   memset(icmp_data,0,MAX_PACKET);
   fill_icmp_data(icmp_data,datasize);

   while(1) {
         int bwrote;
        
         ((IcmpHeader*)icmp_data)->i_cksum = 0;
         ((IcmpHeader*)icmp_data)->timestamp = GetTickCount();

         ((IcmpHeader*)icmp_data)->i_seq = seq_no++;
         ((IcmpHeader*)icmp_data)->i_cksum = checksum((USHORT*)icmp_data, 
                                                                                         datasize);

         bwrote = sendto(sockRaw,icmp_data,datasize,0,(struct sockaddr*)&dest,
                                         sizeof(dest));
         if (bwrote == SOCKET_ERROR){
           if (WSAGetLastError() == WSAETIMEDOUT) {
                   printf("timed out\n");
                 continue;
           }
           fprintf(stderr,"sendto failed: %d\n",WSAGetLastError());
           ExitProcess(STATUS_FAILED);
         }
         if (bwrote < datasize ) {
           fprintf(stdout,"Wrote %d bytes\n",bwrote);
         }
         bread = recvfrom(sockRaw,recvbuf,MAX_PACKET,0,(struct sockaddr*)&from,
                                  &fromlen);
         if (bread == SOCKET_ERROR){
           if (WSAGetLastError() == WSAETIMEDOUT) {
                   printf("timed out\n");
                 continue;
           }
           fprintf(stderr,"recvfrom failed: %d\n",WSAGetLastError());
           ExitProcess(STATUS_FAILED);
         }
         decode_resp(recvbuf,bread,&from);
         Sleep(1000);

   }
   return 0;

}
/* 
         The response is an IP packet. We must decode the IP header to locate 
         the ICMP data 
*/
void decode_resp(char *buf, int bytes,struct sockaddr_in *from) {

         IpHeader *iphdr;
         IcmpHeader *icmphdr;
         unsigned short iphdrlen;

         iphdr = (IpHeader *)buf;

         iphdrlen = iphdr->h_len * 4 ; // number of 32-bit words *4 = bytes

         if (bytes   < iphdrlen + ICMP_MIN) {
                 printf("Too few bytes from %s\n",inet_ntoa(from->sin_addr));
         }

         icmphdr = (IcmpHeader*)(buf + iphdrlen);

         if (icmphdr->i_type != ICMP_ECHOREPLY) {
                 fprintf(stderr,"non-echo type %d recvd\n",icmphdr->i_type);
                 return;
         }
         if (icmphdr->i_id != (USHORT)GetCurrentProcessId()) {
                 fprintf(stderr,"someone else's packet!\n");
                 return ;
         }
         printf("%d bytes from %s:",bytes, inet_ntoa(from->sin_addr));
         printf(" icmp_seq = %d. ",icmphdr->i_seq);
         printf(" time: %d ms ",GetTickCount()-icmphdr->timestamp);
         printf("\n");
                
}


USHORT checksum(USHORT *buffer, int size) {

   unsigned long cksum=0;

   while(size >1) {
         cksum+=*buffer++;
         size -=sizeof(USHORT);
   }
  
   if(size ) {
         cksum += *(UCHAR*)buffer;
   }

   cksum = (cksum >> 16) + (cksum & 0xffff);
   cksum += (cksum >>16);
   return (USHORT)(~cksum);
}
/* 
         Helper function to fill in various stuff in our ICMP request.
*/
void fill_icmp_data(char * icmp_data, int datasize){

   IcmpHeader *icmp_hdr;
   char *datapart;

   icmp_hdr = (IcmpHeader*)icmp_data;

   icmp_hdr->i_type = ICMP_ECHO;
   icmp_hdr->i_code = 0;
   icmp_hdr->i_id = (USHORT)GetCurrentProcessId();
   icmp_hdr->i_cksum = 0;
   icmp_hdr->i_seq = 0;
  
   datapart = icmp_data + sizeof(IcmpHeader);
   //
   // Place some junk in the buffer.
   //
   memset(datapart,'E', datasize - sizeof(IcmpHeader));

}

转自： http://hi.baidu.com/aaaalook/item/e146a41864c9a542e75e0655