C++实现Ping

这是一个老话题了，但是我刚学会...

我们的目的是实现这么个东西：

之所以用红框框一下是因为，从baidu.com到123.125.114.144的过程是DNS解析，我们暂时先实现ping的部分。

基础知识

ping的过程是向目的IP发送一个type=8的ICMP响应请求报文，目标主机收到这个报文之后，会向源IP（发送方，我）回复一个type=0的ICMP响应应答报文。

那上面的字节、往访时间、TTL之类的信息又是从哪来的呢？这取决于IP和ICMP的头部。

IP头部：

头部内容有点多，我们关心的只有以下几个：

IHL：首部长度。因为IP的头部不是定长的，所以需要这个信息进行IP包的解析，从而找到Data字段的起始点。

　　  另外注意这个IHL是以4个字节为单位的，所以首部实际长度是IHL*4字节。

Time to Live：生存时间，这个就是TTL了。

Data：这部分是IP包的数据，也就是ICMP的报文内容。

ICMP响应请求/应答报文头部：

Type：类型，type=8表示响应请求报文，type=0表示响应应答报文。

Code：代码，与type组合，表示具体的信息，参考这里。

Checksum：检验和，这个是整个ICMP报文的检验和，包括Type、Code、...、Data。

Identifier：标识符，这个一般填入本进程的标识符。

Sequence Number：序号

Data：数据部分

上面是标准的ICMP报文，一般而言，统计ping的往返时间的做法是，在ICMP报文的Data区域写入4个字节的时间戳。

在收到应答报文时，取出这个时间戳与当前的时间对比即可。

代码实现

 #pragma once

 #include <windows.h>

 //这里需要导入库 Ws2_32.lib，在不同的IDE下可能不太一样
 //#pragma comment(lib, "Ws2_32.lib")

 #define DEF_PACKET_SIZE 32
 #define ECHO_REQUEST 8
 #define ECHO_REPLY 0

 struct IPHeader
 {
     BYTE m_byVerHLen; //4位版本+4位首部长度
     BYTE m_byTOS; //服务类型
     USHORT m_usTotalLen; //总长度
     USHORT m_usID; //标识
     USHORT m_usFlagFragOffset; //3位标志+13位片偏移
     BYTE m_byTTL; //TTL
     BYTE m_byProtocol; //协议
     USHORT m_usHChecksum; //首部检验和
     ULONG m_ulSrcIP; //源IP地址
     ULONG m_ulDestIP; //目的IP地址
 };

 struct ICMPHeader
 {
     BYTE m_byType; //类型
     BYTE m_byCode; //代码
     USHORT m_usChecksum; //检验和
     USHORT m_usID; //标识符
     USHORT m_usSeq; //序号
     ULONG m_ulTimeStamp; //时间戳（非标准ICMP头部）
 };

 struct PingReply
 {
     USHORT m_usSeq;
     DWORD m_dwRoundTripTime;
     DWORD m_dwBytes;
     DWORD m_dwTTL;
 };

 class CPing
 {
 public:
     CPing();
     ~CPing();
     BOOL Ping(DWORD dwDestIP, PingReply *pPingReply = NULL, DWORD dwTimeout = );
     BOOL Ping(char *szDestIP, PingReply *pPingReply = NULL, DWORD dwTimeout = );
 private:
     BOOL PingCore(DWORD dwDestIP, PingReply *pPingReply, DWORD dwTimeout);
     USHORT CalCheckSum(USHORT *pBuffer, int nSize);
     ULONG GetTickCountCalibrate();
 private:
     SOCKET m_sockRaw;
     WSAEVENT m_event;
     USHORT m_usCurrentProcID;
     char *m_szICMPData;
     BOOL m_bIsInitSucc;
 private:
     static USHORT s_usPacketSeq;
 };

[ping.h]

 #include "ping.h"

 USHORT CPing::s_usPacketSeq = ;

 CPing::CPing() :
     m_szICMPData(NULL),
     m_bIsInitSucc(FALSE)
 {
     WSADATA WSAData;
     WSAStartup(MAKEWORD(, ), &WSAData);

     m_event = WSACreateEvent();
     m_usCurrentProcID = (USHORT)GetCurrentProcessId();

     if ((m_sockRaw = WSASocket(AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, , )) != SOCKET_ERROR)
     {
         WSAEventSelect(m_sockRaw, m_event, FD_READ);
         m_bIsInitSucc = TRUE;

         m_szICMPData = (char*)malloc(DEF_PACKET_SIZE + sizeof(ICMPHeader));

         if (m_szICMPData == NULL)
         {
             m_bIsInitSucc = FALSE;
         }
     }
 }

 CPing::~CPing()
 {
     WSACleanup();

     if (NULL != m_szICMPData)
     {
         free(m_szICMPData);
         m_szICMPData = NULL;
     }
 }

 BOOL CPing::Ping(DWORD dwDestIP, PingReply *pPingReply, DWORD dwTimeout)
 {
     return PingCore(dwDestIP, pPingReply, dwTimeout);
 }

 BOOL CPing::Ping(char *szDestIP, PingReply *pPingReply, DWORD dwTimeout)
 {
     if (NULL != szDestIP)
     {
         return PingCore(inet_addr(szDestIP), pPingReply, dwTimeout);
     }
     return FALSE;
 }

 BOOL CPing::PingCore(DWORD dwDestIP, PingReply *pPingReply, DWORD dwTimeout)
 {
     //判断初始化是否成功
     if (!m_bIsInitSucc)
     {
         return FALSE;
     }

     //配置SOCKET
     sockaddr_in sockaddrDest;
     sockaddrDest.sin_family = AF_INET;
     sockaddrDest.sin_addr.s_addr = dwDestIP;
     int nSockaddrDestSize = sizeof(sockaddrDest);

     //构建ICMP包
     int nICMPDataSize = DEF_PACKET_SIZE + sizeof(ICMPHeader);
     ULONG ulSendTimestamp = GetTickCountCalibrate();
     USHORT usSeq = ++s_usPacketSeq;
     memset(m_szICMPData, , nICMPDataSize);
     ICMPHeader *pICMPHeader = (ICMPHeader*)m_szICMPData;
     pICMPHeader->m_byType = ECHO_REQUEST;
     pICMPHeader->m_byCode = ;
     pICMPHeader->m_usID = m_usCurrentProcID;
     pICMPHeader->m_usSeq = usSeq;
     pICMPHeader->m_ulTimeStamp = ulSendTimestamp;
     pICMPHeader->m_usChecksum = CalCheckSum((USHORT*)m_szICMPData, nICMPDataSize);

     //发送ICMP报文
     if (sendto(m_sockRaw, m_szICMPData, nICMPDataSize, , (struct sockaddr*)&sockaddrDest, nSockaddrDestSize) == SOCKET_ERROR)
     {
         return FALSE;
     }

     //判断是否需要接收相应报文
     if (pPingReply == NULL)
     {
         return TRUE;
     }

     char recvbuf[] = {"\0"};
     while (TRUE)
     {
         //接收响应报文
         if (WSAWaitForMultipleEvents(, &m_event, FALSE, , FALSE) != WSA_WAIT_TIMEOUT)
         {
             WSANETWORKEVENTS netEvent;
             WSAEnumNetworkEvents(m_sockRaw, m_event, &netEvent);

             if (netEvent.lNetworkEvents & FD_READ)
             {
                 ULONG nRecvTimestamp = GetTickCountCalibrate();
                 int nPacketSize = recvfrom(m_sockRaw, recvbuf, , , (struct sockaddr*)&sockaddrDest, &nSockaddrDestSize);
                 if (nPacketSize != SOCKET_ERROR)
                 {
                     IPHeader *pIPHeader = (IPHeader*)recvbuf;
                     USHORT usIPHeaderLen = (USHORT)((pIPHeader->m_byVerHLen & 0x0f) * );
                     ICMPHeader *pICMPHeader = (ICMPHeader*)(recvbuf + usIPHeaderLen);

                     if (pICMPHeader->m_usID == m_usCurrentProcID //是当前进程发出的报文
                         && pICMPHeader->m_byType == ECHO_REPLY //是ICMP响应报文
                         && pICMPHeader->m_usSeq == usSeq //是本次请求报文的响应报文
                         )
                     {
                         pPingReply->m_usSeq = usSeq;
                         pPingReply->m_dwRoundTripTime = nRecvTimestamp - pICMPHeader->m_ulTimeStamp;
                         pPingReply->m_dwBytes = nPacketSize - usIPHeaderLen - sizeof(ICMPHeader);
                         pPingReply->m_dwTTL = pIPHeader->m_byTTL;
                         return TRUE;
                     }
                 }
             }
         }
         //超时
         if (GetTickCountCalibrate() - ulSendTimestamp >= dwTimeout)
         {
             return FALSE;
         }
     }
 }

 USHORT CPing::CalCheckSum(USHORT *pBuffer, int nSize)
 {
     unsigned long ulCheckSum=;
     while(nSize > )
     {
         ulCheckSum += *pBuffer++;
         nSize -= sizeof(USHORT);
     }
     if(nSize )
     {
         ulCheckSum += *(UCHAR*)pBuffer;
     } 

     ulCheckSum = (ulCheckSum >> ) + (ulCheckSum & 0xffff);
     ulCheckSum += (ulCheckSum >>); 

     return (USHORT)(~ulCheckSum);
 }

 ULONG CPing::GetTickCountCalibrate()
 {
     static ULONG s_ulFirstCallTick = ;
     static LONGLONG s_ullFirstCallTickMS = ;

     SYSTEMTIME systemtime;
     FILETIME filetime;
     GetLocalTime(&systemtime);
     SystemTimeToFileTime(&systemtime, &filetime);
     LARGE_INTEGER liCurrentTime;
     liCurrentTime.HighPart = filetime.dwHighDateTime;
     liCurrentTime.LowPart = filetime.dwLowDateTime;
     LONGLONG llCurrentTimeMS = liCurrentTime.QuadPart / ;

     if (s_ulFirstCallTick == )
     {
         s_ulFirstCallTick = GetTickCount();
     }
     if (s_ullFirstCallTickMS == )
     {
         s_ullFirstCallTickMS = llCurrentTimeMS;
     }

     return s_ulFirstCallTick + (ULONG)(llCurrentTimeMS - s_ullFirstCallTickMS);
 }

[ping.cpp]

 #include <windows.h>
 #include <stdio.h>
 #include "ping.h"

 int main(void)
 {
     CPing objPing;  

     char *szDestIP = "123.125.114.144";
     PingReply reply;

     printf("Pinging %s with %d bytes of data:\n", szDestIP, DEF_PACKET_SIZE);
     while (TRUE)
     {
         objPing.Ping(szDestIP, &reply);
         printf("Reply from %s: bytes=%ld time=%ldms TTL=%ld\n", szDestIP, reply.m_dwBytes, reply.m_dwRoundTripTime, reply.m_dwTTL);
         Sleep();
     }

     return ;
 }

执行结果

附录：如何计算检验和

ICMP中检验和的计算算法为：

1、将检验和字段置为0

2、把需校验的数据看成以16位为单位的数字组成，依次进行二进制反码求和

3、把得到的结果存入检验和字段中

所谓二进制反码求和，就是：

1、将源数据转成反码

2、0+0=0   0+1=1   1+1=0进1

3、若最高位相加后产生进位，则最后得到的结果要加1

在实际实现的过程中，比较常见的代码写法是：

1、将检验和字段置为0

2、把需校验的数据看成以16位为单位的数字组成，依次进行求和，并存到32位的整型中

3、把求和结果中的高16位(进位)加到低16位上，如果还有进位，重复第3步[实际上，这一步最多会执行2次]

4、将这个32位的整型按位取反，并强制转换为16位整型(截断)后返回

[转载请保留本文地址：http://www.cnblogs.com/*/p/4078940.html]