c++ ping 功能实现

#if !defined(COMMON_FDSET_H)
#define COMMON_FDSET_H  

#include <cassert>
#include <errno.h>
#include <algorithm>

#ifdef WIN32
//#include <winsock2.h>
#include <WS2TCPIP.H>
#include <stdlib.h>
#include <io.h>
#endif



#ifndef WIN32
typedef int SOCKET;
#define INVALID_SOCKET (-1)
#define SOCKET_ERROR   (-1)
#else
//typedef SOCKET SOCKET;
#endif

int closeSocket( SOCKET fd );

class FdSet
{
public:
   FdSet() : size(0), numReady(0)
   {
      FD_ZERO(&read);
      FD_ZERO(&write);
      FD_ZERO(&except);
   }

   int select(struct timeval& tv)
   {
      return numReady = ::select(size, &read, &write, &except, &tv);
   }

   int selectMilliSeconds(unsigned long ms)
   {
      struct timeval tv;
      tv.tv_sec = (ms/1000);
      tv.tv_usec = (ms%1000)*1000;
      return select(tv);
   }

   bool readyToRead(SOCKET fd)
   {
      return (FD_ISSET(fd, &read) != 0);
   }

   bool readyToWrite(SOCKET fd)
   {
      return (FD_ISSET(fd, &write) != 0);
   }

   bool hasException(SOCKET fd)
   {
      return (FD_ISSET(fd,&except) != 0);
   }

   void setRead(SOCKET fd)
   {
      assert( FD_SETSIZE >= 8 );
      FD_SET(fd, &read);
      size = ( int(fd+1) > size) ? int(fd+1) : size;
   }

   void setWrite(SOCKET fd)
   {
      FD_SET(fd, &write);
      size = ( int(fd+1) > size) ? int(fd+1) : size;
   }

   void setExcept(SOCKET fd)
   {
      FD_SET(fd,&except);
      size = ( int(fd+1) > size) ? int(fd+1) : size;
   }


   void clear(SOCKET fd)
   {
      FD_CLR(fd, &read);
      FD_CLR(fd, &write);
      FD_CLR(fd, &except);
   }

   void reset()
   {
      size = 0;
      numReady = 0;
      FD_ZERO(&read);
      FD_ZERO(&write);
      FD_ZERO(&except);
   }

   // Make this stuff public for async dns/ares to use
   fd_set read;
   fd_set write;
   fd_set except;
   int size;
   int numReady;  // set after each select call
};


#endif 

#include <assert.h>
#include <fcntl.h>

#ifndef WIN32
#include <errno.h>
#include <unistd.h>
#endif

#include "FdSet.h"


using namespace std;


#ifdef WIN32

typedef int socklen_t;

#define EWOULDBLOCK             WSAEWOULDBLOCK
#define EINPROGRESS             WSAEINPROGRESS
#define EALREADY                WSAEALREADY
#define ENOTSOCK                WSAENOTSOCK
#define EDESTADDRREQ            WSAEDESTADDRREQ
#define EMSGSIZE                WSAEMSGSIZE
#define EPROTOTYPE              WSAEPROTOTYPE
#define ENOPROTOOPT             WSAENOPROTOOPT
#define EPROTONOSUPPORT         WSAEPROTONOSUPPORT
#define ESOCKTNOSUPPORT         WSAESOCKTNOSUPPORT
#define EOPNOTSUPP              WSAEOPNOTSUPP
#define EPFNOSUPPORT            WSAEPFNOSUPPORT
#define EAFNOSUPPORT            WSAEAFNOSUPPORT
#define EADDRINUSE              WSAEADDRINUSE
#define EADDRNOTAVAIL           WSAEADDRNOTAVAIL
#define ENETDOWN                WSAENETDOWN
#define ENETUNREACH             WSAENETUNREACH
#define ENETRESET               WSAENETRESET
#define ECONNABORTED            WSAECONNABORTED
#define ECONNRESET              WSAECONNRESET
#define ENOBUFS                 WSAENOBUFS
#define EISCONN                 WSAEISCONN
#define ENOTCONN                WSAENOTCONN
#define ESHUTDOWN               WSAESHUTDOWN
#define ETOOMANYREFS            WSAETOOMANYREFS
#define ETIMEDOUT               WSAETIMEDOUT
#define ECONNREFUSED            WSAECONNREFUSED
#define ELOOP                   WSAELOOP
#define EHOSTDOWN               WSAEHOSTDOWN
#define EHOSTUNREACH            WSAEHOSTUNREACH
#define EPROCLIM                WSAEPROCLIM
#define EUSERS                  WSAEUSERS
#define EDQUOT                  WSAEDQUOT
#define ESTALE                  WSAESTALE
#define EREMOTE                 WSAEREMOTE

#else
	#define WSANOTINITIALISED  EPROTONOSUPPORT
#endif


int closeSocket( SOCKET fd )
{
#if defined(WIN32)
	return closesocket(fd);
#else 
	int ret = ::close(fd);
	return ret;
#endif
}




 

#ifndef __SocketPing_H__
#define __SocketPing_H__

#include "FdSet.h"


#define ICMP_ECHO       8 
#define ICMP_ECHOREPLY  0 

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

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

/* The IP header */ 
typedef struct ip_hdr 
{ 
	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; 


//IP option header--use with socket option IP_OPTIONS   
typedef struct _ipoptionhdr  
{  
    unsigned char code;     // Option type   
    unsigned char len;      // Length of option hdr   
    unsigned char ptr;      // Offset into optons   
    unsigned long addr[9];  // List of IP addrs   
} IpOptionHeader;

// ping
bool Ping(const char * ip, int try_count = 4, int timeout = 3000);

#endif /*__SocketPing_H__*/

#include "SocketPing.h"


/*lint -e830*/
static USHORT MakeIcmpID()
{
	static CMutex   g_mutex;
	CGuard   guard(&g_mutex);
	static USHORT iIcmpID = 1;
	return iIcmpID++;
}

static 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. 
*/ 
static void fill_icmp_data(char * icmp_data, int datasize, USHORT icmp_id)
{ 
	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    = icmp_id;//ICMP_MAGIC; 
	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)); 
} 

/* 
The response is an IP packet. We must decode the IP header to locate 
the ICMP data
//成功返回0；失败返回-1；如果收到别人回复返回1
*/ 
static int decode_resp(char *buf, int bytes,struct sockaddr_in *from, const char * ip, USHORT icmp_id) 
{ 
	IpHeader * iphdr = (IpHeader *)buf; 

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

	if (bytes < iphdrlen + ICMP_MIN) 
	{ 
		SOCKETDEV_ERROR("Ping [%s] too few bytes", ip); 
		return -1;
	} 

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

	if (icmphdr->i_type != ICMP_ECHOREPLY) 
	{ 
		SOCKETDEV_ERROR("Ping [%s], no echo reply", ip, icmphdr->i_type); 
		return -1; 
	} 

	if (icmphdr->i_id != icmp_id) 
	{
		//SOCKET_LOG_ERROR("Ping [%s] error magic packet", ip); 
		return 1; 
	} 

	return 0;
} 

static bool send_icmp_data(SOCKET sock_raw, const char * ip, USHORT icmp_id,  int try_count, int timeout)
{
	int seq_no = 0;
	char icmp_data[MAX_PACKET] = {0};

	sockaddr_in dest = {0};
	dest.sin_family = AF_INET;
	dest.sin_addr.s_addr = inet_addr( ip );

	bool success = false;
	bool needToSendPingReq = true;
	while(try_count-- > 0)
	{
		bool isToSendPingReq = needToSendPingReq;
		needToSendPingReq = true;
		if(isToSendPingReq)
		{
			memset(icmp_data,0,MAX_PACKET); 
			fill_icmp_data(icmp_data, DEF_PACKET_SIZE, icmp_id); 

			((IcmpHeader*)icmp_data)->i_cksum = 0; 
			((IcmpHeader*)icmp_data)->timestamp = GetTickCount(); 

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

			int bwrote = sendto(sock_raw, icmp_data, DEF_PACKET_SIZE, 0, (struct sockaddr*)&dest,  sizeof(dest)); 

			if (bwrote == SOCKET_ERROR)
			{ 
				if (WSAGetLastError() == WSAETIMEDOUT) 
				{ 
					SOCKETDEV_ERROR("Ping [%s] timed out", ip); 
					continue; 
				} 

				SOCKETDEV_ERROR("Ping [%s] packet send failed: %d", ip, WSAGetLastError()); 
				continue;
			} 

			if (bwrote < DEF_PACKET_SIZE )
			{ 
				continue;
			} 
		}
	
		char recvbuf[MAX_PACKET] = {0};
		struct sockaddr_in from; 
		int fromlen = sizeof(from); 

		FdSet fdset;
		fdset.setRead(sock_raw);
		timeval val;
		val.tv_sec = timeout / 1000;
		val.tv_usec = (timeout%1000)*1000;

		int bread = SOCKET_ERROR;
		bool bTimeout =false;
		do 
		{
			int selectRet = fdset.select(val);
			if(selectRet == 0)
			{//超时
				bTimeout = true;
				break;
			}
			else if(selectRet < 0)
			{//发生错误
				break;
			}
			if(fdset.readyToRead(sock_raw))
			{
				bread = recvfrom(sock_raw, recvbuf, MAX_PACKET, 0, (struct sockaddr*)&from, &fromlen); 
			}
		} while (0);

		if(bTimeout || (bread <= 0 && WSAGetLastError() == WSAETIMEDOUT))
		{
			SOCKETDEV_ERROR("Ping [%s] timed out", ip); 
			continue; 
		}

		if (bread <= 0)
		{ 
			SOCKETDEV_ERROR("Ping [%s] recv failed: %d", ip, WSAGetLastError()); 
			continue;
		} 

		int ret = decode_resp(recvbuf, bread, &from, ip, icmp_id); 
		if(ret == 0)
		{
			success = true;
			break;
		}
		else if(ret == 1)
		{
            //接收了别的ping回复，需要重新接收 
			needToSendPingReq = false;
			++ try_count;
			continue;
		}
		//失败
		continue;
	}

	return success;
}

//ping
bool Ping(const char * ip, int try_count, int timeout)
{
	SOCKET sock_raw; 

	bool success = false;
	
	USHORT icmp_id = MakeIcmpID();

	do 
	{
		sock_raw = WSASocket (AF_INET, SOCK_RAW, IPPROTO_ICMP, NULL, 0, WSA_FLAG_OVERLAPPED); 

		if (sock_raw == INVALID_SOCKET) 
		{ 
			SOCKETDEV_ERROR("WSASocket failed");
			break;
		} 

		unsigned int beginTick = GetTickCount(); //统计时间开始

		char icmp_data[MAX_PACKET] = {0};
		fill_icmp_data(icmp_data, MAX_PACKET, icmp_id); 
		success = send_icmp_data(sock_raw, ip, icmp_id, try_count, timeout);

		unsigned int endTick = GetTickCount();  //统计时间结束
		if (success)
		{
			SOCKETDEV_INFO("Ping [%s] success, use %u ms", ip, (endTick - beginTick) );
		}
		else
		{
			SOCKETDEV_ERROR("Ping [%s] failed, use %u ms", ip, (endTick - beginTick));
		}

	} while (0);

	if (sock_raw != INVALID_SOCKET)
	{
		closesocket(sock_raw);
	}

	return success;
}

/*lint +e830*/