//ping.h======================

#pragma pack(1)

#define ICMP_ECHOREPLY        0
#define ICMP_ECHOREQ        8
#define REQ_DATASIZE 32

class CPing
{
public:
        HWND m_hWnd;
        void Ping(UINT nRetries,LPCSTR pstrHost,HWND hWnd);
        int  WaitForEchoReply(SOCKET s);

        int                SendEchoRequest(SOCKET, LPSOCKADDR_IN);
        DWORD        RecvEchoReply(SOCKET, LPSOCKADDR_IN, u_char *);
        u_short in_cksum(u_short *addr, int len);

protected:
        void WSAError(LPCSTR pstrFrom);

};

typedef struct tagIPHDR
{
        u_char  VIHL;
        u_char        TOS;
        short        TotLen;       
        short        ID;
        short        FlagOff;
        u_char        TTL;
        u_char        Protocol;
        u_short        Checksum;
        struct        in_addr iaSrc;
        struct        in_addr iaDst;
}IPHDR, *PIPHDR;

typedef struct tagICMPHDR
{
        u_char        Type;
        u_char        Code;
        u_short        Checksum;
        u_short        ID;
        u_short        Seq;
        char        Data;                       
}ICMPHDR, *PICMPHDR;

typedef struct tagECHOREQUEST
{
        ICMPHDR icmpHdr;
        DWORD        dwTime;
        char        cData[REQ_DATASIZE];
}ECHOREQUEST, *PECHOREQUEST;

typedef struct tagECHOREPLY
{
        IPHDR        ipHdr;
        ECHOREQUEST        echoRequest;
        char    cFiller[256];
}ECHOREPLY, *PECHOREPLY;

#pragma pack()

//ping.cpp=================================
#include "stdafx.h"
#include "ping.h"

void CPing::Ping(UINT nRetries,LPCSTR pstrHost,HWND hWnd)
{
        SOCKET          rawSocket;
        LPHOSTENT lpHost;
        UINT          nLoop;
        int       nRet;
        struct    sockaddr_in saDest;
        struct    sockaddr_in saSrc;
        DWORD          dwTimeSent;
        DWORD          dwElapsed;
        u_char    cTTL;

        m_hWnd = hWnd;

        CString str;

        ASSERT(IsWindow(hWnd));

        rawSocket = socket(AF_INET, SOCK_RAW, IPPROTO_ICMP);
        if (rawSocket == SOCKET_ERROR)
        {
                WSAError("socket()");
                return;
        }
       
        lpHost = gethostbyname(pstrHost);
        if (lpHost == NULL)
        {
                str.Format("Host not found: %s", pstrHost);
                ::PostMessage(m_hWnd,WM_MSG_STATUS, 0, (LPARAM) AllocBuffer(str));
                ::PostMessage(m_hWnd,WM_PING_END, 0, 0);
                return;
        }
       
        saDest.sin_addr.s_addr = *((u_long FAR *) (lpHost->h_addr));
        saDest.sin_family = AF_INET;
        saDest.sin_port = 3077;

        str.Format("Pinging %s [%s] with %d bytes of data:",
                                pstrHost,
                                inet_ntoa(saDest.sin_addr),
                                REQ_DATASIZE);
        ::PostMessage(m_hWnd,WM_MSG_STATUS, 1, (LPARAM) AllocBuffer(str));

        for (nLoop = 0; nLoop < nRetries;)
        {
                if(nRetries<1000)
                        nLoop++;

                SendEchoRequest(rawSocket, &saDest);

                nRet = WaitForEchoReply(rawSocket);
                if (nRet == SOCKET_ERROR)
                {
                        WSAError("select()");
                        break;
                }
                if (!nRet)
                {
                        str.Format("Request Timed Out");
                        ::PostMessage(m_hWnd,WM_MSG_STATUS, 3, (LPARAM) AllocBuffer(str));
                }
                else

                {
                        dwTimeSent = RecvEchoReply(rawSocket, &saSrc, &cTTL);

                        dwElapsed = GetTickCount() - dwTimeSent;
                        str.Format("Reply[%d] from: %s: bytes=%d time=%ldms TTL=%d",
                                nLoop+1,
                                   inet_ntoa(saSrc.sin_addr),
                                   REQ_DATASIZE,
                                   dwElapsed,
                                   cTTL);

                        ::PostMessage(m_hWnd,WM_MSG_STATUS, 2, (LPARAM) AllocBuffer(str));

                        Sleep(1000);

                }

                        BOOL t1,t2=0;
                       
                        int t3=GetDlgItemInt(m_hWnd,1011,&t1,t2);
                        if(t3==1)
                                break;

        }
       
        ::PostMessage(m_hWnd,WM_PING_END, 0, 1);

        nRet = closesocket(rawSocket);
        if (nRet == SOCKET_ERROR)
                WSAError("closesocket()");

}

int CPing::SendEchoRequest(SOCKET s,LPSOCKADDR_IN lpstToAddr)
{
        static ECHOREQUEST echoReq;
        static nId = 1;
        static nSeq = 1;
        int nRet;

        echoReq.icmpHdr.Type                = ICMP_ECHOREQ;
        echoReq.icmpHdr.Code                = 0;
        echoReq.icmpHdr.Checksum        = 0;
        echoReq.icmpHdr.ID                        = nId++;
        echoReq.icmpHdr.Seq                        = nSeq++;

        for (nRet = 0; nRet < REQ_DATASIZE; nRet++)
                echoReq.cData[nRet] = ' '+nRet;

        echoReq.dwTime                                = GetTickCount();

        echoReq.icmpHdr.Checksum = in_cksum((u_short *)&echoReq, sizeof(ECHOREQUEST));

        nRet = sendto(s,                                               
                                 (LPSTR)&echoReq,                       
                                 sizeof(ECHOREQUEST),
                                 0,                                                       
                                 (LPSOCKADDR)lpstToAddr,
                                 sizeof(SOCKADDR_IN));   

        if (nRet == SOCKET_ERROR)
                WSAError("sendto()");
        return (nRet);
}

DWORD CPing::RecvEchoReply(SOCKET s, LPSOCKADDR_IN lpsaFrom, u_char *pTTL)
{
        ECHOREPLY echoReply;
        int nRet;
        int nAddrLen = sizeof(struct sockaddr_in);

        nRet = recvfrom(s,                                       
                                        (LPSTR)&echoReply,       
                                        sizeof(ECHOREPLY),       
                                        0,                                       
                                        (LPSOCKADDR)lpsaFrom,
                                        &nAddrLen);                       

        if (nRet == SOCKET_ERROR)
                WSAError("recvfrom()");

        *pTTL = echoReply.ipHdr.TTL;

        return(echoReply.echoRequest.dwTime);                  
}

int CPing::WaitForEchoReply(SOCKET s)
{
        struct timeval Timeout;
        fd_set readfds;

        readfds.fd_count = 1;
        readfds.fd_array[0] = s;
        Timeout.tv_sec = 1;
    Timeout.tv_usec = 0;

        return(select(1, &readfds, NULL, NULL, &Timeout));
}

void CPing::WSAError(LPCSTR lpMsg)
{
        CString strMsg;
        strMsg.Format("%s - WSAError: %ld",lpMsg,WSAGetLastError());       
        ::PostMessage(m_hWnd,WM_MSG_STATUS, 0, (LPARAM) AllocBuffer(strMsg));
}

u_short CPing::in_cksum(u_short *addr, int len)
{
        register int nleft = len;
        register u_short *w = addr;
        register u_short answer;
        register int sum = 0;

        while( nleft > 1 )  {
                sum += *w++;
                nleft -= 2;
        }

        if( nleft == 1 ) {
                u_short        u = 0;

                *(u_char *)(&u) = *(u_char *)w ;
                sum += u;
        }

        sum = (sum >> 16) + (sum & 0xffff);       
        sum += (sum >> 16);                       
        answer = ~sum;                               
        return (answer);
}

[课程]Android-CTF解题方法汇总！