ICMP

UserPreferences

1. 개요
2. ICMP library on Win32
1. Usage Sample
2. ICMPRepository.h
3. ICMPRepository.cpp
3. Ping Implementation
1. Microsoft ICMP Library Version
1. PingI.c
2. RAW Socket Version
1. Ping.h
2. Ping.c

1 개요

Internet Control Message Protocol, 줄여서 ICMP에 관한 내용들이다.

2 ICMP library on Win32

Win32 상에서 구현한 Internet Control Message Protocol (ICMP) 라이브러리다. 원래 소스 파일은 C로 구현되어 있었고, 싱글 쓰레드였다. icmp.dll 내부에 있는 함수를 이용하는데 이 함수가 블록킹이 되는 함수기 때문에 실제로 게임 서버 등에서 쓰려면 멀티 쓰레딩이 필수다. 그래서 멀티 쓰레딩과 관련된 코드를 집어넣었다.

다음은 원래 소스에 있던 머릿말이다.


/*------------------------------------------------------------------    
 * Filename: MS_ICMP.H
 *
 * Description:
 *  Prototypes and typedefs Microsoft's ICMP.DLL functions & structs
 *  for access to Internet Control Message Protocol.  This is capable
 *  of doing "ping or "traceroute", although beware that Microsoft 
 *  discourages the use of these APIs.
 *
 * Some Background:
 *
 * The standard Berkeley Sockets SOCK_RAW socket type, is normally used
 * to create ping (echo request/reply), and sometimes traceroute applications
 * (the original traceroute application from Van Jacobson used UDP, rather
 * than ICMP). Microsoft's WinSock version 2 implementations for NT4 and 
 * Windows 95 support raw sockets, but none of their WinSock version 1.1
 * implementations (WFWG, NT3.x or standard Windows 95) did.
 *
 * Microsoft has their own API for an ICMP.DLL that their ping and tracert
 * applications use (by the way, they are both non-GUI text-based console
 * applications. This is a proprietary API, and all function calls that 
 * involve network functions operate in blocking mode. They still include 
 * it with WinSock 2 implementations.
 *
 * There is little documentation available (I first found it in the Win32
 * SDK in \MSTOOLS\ICMP, and it exists on the MS Developers' Network
 * CD-ROM now, also). Microsoft disclaims this API about as strongly as 
 * possible.  The README.TXT that accompanies it says:
 *
 * [DISCLAIMER]
 * 
 * We have had requests in the past to expose the functions exported from
 * icmp.dll. The files in this directory are provided for your convenience
 * in building applications which make use of ICMPSendEcho(). Notice that
 * the functions in icmp.dll are not considered part of the Win32 API and
 * will not be supported in future releases. Once we have a more complete
 * solution in the operating system, this DLL, and the functions it exports,
 * will be dropped.    
 *      
 * [DOCUMENTATION]     
 *
 * The ICMPSendEcho() function sends an ICMP echo request to the specified
 * destination IP address and returns any replies received within the timeout
 * specified. The API is synchronous, requiring the process to spawn a thread
 * before calling the API to avoid blocking. An open IcmpHandle is required
 * for the request to complete. IcmpCreateFile() and IcmpCloseHandle() 
 * functions are used to create and destroy the context handle.</P>
 */

아래의 코드들은 샘플 코드와 라이브러리 헤더, 구현 파일로 나뉘어져 있는데, 소스를 그냥 긁어서 컴파일하면 컴파일되지 않는다. 크리티컬 섹션이라든지 싱글레톤 패턴 등에 관한 헤더 파일도 같이 있어야 컴파일이 된다. 적당히 잘~ 고쳐서 컴파일해보기 바란다.



2.1 Usage Sample

#include "ICMPRepository.h"
#include <conio.h>

void main()
{
    Socket::initializeWinsock();

    //g_pICMPRepository->enqueueRequest("155.230.29.10", ICMP_REQUEST_CLASS_PING);
    g_pICMPRepository->enqueueRequest("155.230.29.10", ICMP_REQUEST_CLASS_TRACEROUTE);

    while (true)
    {
        ICMP_RESULT* pResult = g_pICMPRepository->getResult("155.230.29.10");
        if (pResult != NULL)
        {
            cout << "*** PING RESULT ***" << endl;
            cout << "Average Time : " << pResult->AverageTime << endl;
            cout << "Bytes Transffered : " << pResult->BytesTransferred << endl;

            cout << "*** TRACEROUTE RESULT ***" << endl;
            ICMP_HOP_LIST::const_iterator itr = pResult->HopList.begin();
            for (; itr != pResult->HopList.end(); itr++)
            {
                cout << "HOP:" << *itr << endl;
            }

            break;
        }
        else
        {
            Sleep(1000);
        }
    }

    _getch();

    Socket::finalizeWinsock();
}





2.2 ICMPRepository.h

#ifndef __ICMPREPOSITORY_H__
#define __ICMPREPOSITORY_H__

#ifndef __MTYPES_H__
    #include "MTypes.h"
#endif

#ifndef __SINGLETON_H__
    #include "Singleton.h"
#endif

#ifndef __STRINGHASHMAP_H__
    #include "StringHashMap.h"
#endif

#ifndef __THREAD_H__
    #include "Thread.h"
#endif

#ifndef _LIST_
    #include <list>
#endif

//----------------------------------------------------------------------------
enum ICMPStatus
{
    IP_STATUS_BASE           = 11000,
    IP_SUCCESS               = 0,
    IP_BUF_TOO_SMALL         = IP_STATUS_BASE + 1,
    IP_DEST_NET_UNREACHABLE  = IP_STATUS_BASE + 2,
    IP_DEST_HOST_UNREACHABLE = IP_STATUS_BASE + 3,
    IP_DEST_PROT_UNREACHABLE = IP_STATUS_BASE + 4,
    IP_DEST_PORT_UNREACHABLE = IP_STATUS_BASE + 5,
    IP_NO_RESOURCES          = IP_STATUS_BASE + 6,
    IP_BAD_OPTION            = IP_STATUS_BASE + 7,
    IP_HW_ERROR              = IP_STATUS_BASE + 8,
    IP_PACKET_TOO_BIG        = IP_STATUS_BASE + 9,
    IP_REQ_TIMED_OUT         = IP_STATUS_BASE + 10,
    IP_BAD_REQ               = IP_STATUS_BASE + 11,
    IP_BAD_ROUTE             = IP_STATUS_BASE + 12,
    IP_TTL_EXPIRED_TRANSIT   = IP_STATUS_BASE + 13,
    IP_TTL_EXPIRED_REASSEM   = IP_STATUS_BASE + 14,
    IP_PARAM_PROBLEM         = IP_STATUS_BASE + 15,
    IP_SOURCE_QUENCH         = IP_STATUS_BASE + 16,
    IP_OPTION_TOO_BIG        = IP_STATUS_BASE + 17,
    IP_BAD_DESTINATION       = IP_STATUS_BASE + 18,
    IP_ADDR_DELETED          = IP_STATUS_BASE + 19,
    IP_SPEC_MTU_CHANGE       = IP_STATUS_BASE + 20,
    IP_MTU_CHANGE            = IP_STATUS_BASE + 21,
    IP_UNLOAD                = IP_STATUS_BASE + 22,
    IP_GENERAL_FAILURE       = IP_STATUS_BASE + 50,
    MAX_IP_STATUS            = IP_GENERAL_FAILURE,
    IP_PENDING               = IP_STATUS_BASE + 255
};

//----------------------------------------------------------------------------
// ICMPSendEcho Error String
// The values in the status word returned in the ICMP Echo 
// Reply buffer after calling IcmpSendEcho() all have a
// base value of 11000 (IP_STATUS_BASE).  At times,
// when IcmpSendEcho() fails outright, GetLastError() will 
// subsequently return these error values also.
// Two Errors value defined in ms_icmp.h are missing from 
// this string table (just to simplify use of the table):
// "IP_GENERAL_FAILURE (11050)"
// "IP_PENDING (11255)"
//----------------------------------------------------------------------------
const IDSTRING ICMPStatus2String[] = 
{
    {IP_STATUS_BASE,           "IP_STATUS_BASE (11000)"},
    {IP_BUF_TOO_SMALL,         "IP_BUF_TOO_SMALL (11001)"},
    {IP_DEST_NET_UNREACHABLE,  "IP_DEST_NET_UNREACHABLE (11002)"}, 
    {IP_DEST_HOST_UNREACHABLE, "IP_DEST_HOST_UNREACHABLE (11003)"}, 
    {IP_DEST_PROT_UNREACHABLE, "IP_DEST_PROT_UNREACHABLE (11004)"}, 
    {IP_DEST_PORT_UNREACHABLE, "IP_DEST_PORT_UNREACHABLE (11005)"}, 
    {IP_NO_RESOURCES,          "IP_NO_RESOURCES (11006)"}, 
    {IP_BAD_OPTION,            "IP_BAD_OPTION (11007)"}, 
    {IP_HW_ERROR,              "IP_HW_ERROR (11008)"}, 
    {IP_PACKET_TOO_BIG,        "IP_PACKET_TOO_BIG (11009)"}, 
    {IP_REQ_TIMED_OUT,         "IP_REQ_TIMED_OUT (11010)"}, 
    {IP_BAD_REQ,               "IP_BAD_REQ (11011)"}, 
    {IP_BAD_ROUTE,             "IP_BAD_ROUTE (11012)"}, 
    {IP_TTL_EXPIRED_TRANSIT,   "IP_TTL_EXPIRED_TRANSIT (11013)"}, 
    {IP_TTL_EXPIRED_REASSEM,   "IP_TTL_EXPIRED_REASSEM (11014)"}, 
    {IP_PARAM_PROBLEM,         "IP_PARAM_PROBLEM (11015)"}, 
    {IP_SOURCE_QUENCH,         "IP_SOURCE_QUENCH (11016)"}, 
    {IP_OPTION_TOO_BIG,        "IP_OPTION_TOO_BIG (11017)"}, 
    {IP_BAD_DESTINATION,       "IP_BAD_DESTINATION (11018)"}, 
    {IP_ADDR_DELETED,          "IP_ADDR_DELETED (11019)"}, 
    {IP_SPEC_MTU_CHANGE,       "IP_SPEC_MTU_CHANGE (11020)"}, 
    {IP_MTU_CHANGE,            "IP_MTU_CHANGE (11021)"}, 
    {IP_UNLOAD,                "IP_UNLOAD (11022)"}, 
    {IP_GENERAL_FAILURE,       "IP_GENERAL_FAILURE"}, 
    {-1,                       NULL}
};

//----------------------------------------------------------------------------
// IP Flags - 3 bits
// bit 0: reserved
// bit 1: 0=May Fragment, 1=Don't Fragment
// bit 2: 0=Last Fragment, 1=More Fragments
//----------------------------------------------------------------------------
#define IPFLAG_DONT_FRAGMENT 0x02

//----------------------------------------------------------------------------
// Router Alert is defined by Dave Katz of Cisco in 
//  ftp://ds.internic.net/rfc/rfc2113.txt
// and is used by RSVP and IGMPv2
// 
// The Router Alert option has the following format:
// 
//   +--------+--------+--------+--------+
//   |10010100|00000100|  2 octet value  |
//   +--------+--------+--------+--------+
// 
// Type:
//   Copied flag:   1  (all fragments must carry the option)
//   Option class:  0  (control)
//   Option number: 20 (decimal)
// 
// Length: 4
// 
// Value:  A two octet code with the following values:
//   0 - Router shall examine packet
//   1 - 65535 - Reserved
//----------------------------------------------------------------------------
#define IPOPT_ROUTER_ALERT 0x94040000L

//----------------------------------------------------------------------------
// *** Note 2 ***
// For the most part, you can refer to RFC 791 for detials 
// on how to fill in values for the IP option information structure. 
//----------------------------------------------------------------------------
typedef struct ip_option_information 
{
    unsigned char      TTL;         // Time To Live (used for traceroute)
    unsigned char      TOS;         // Type Of Service (usually 0)
    unsigned char      Flags;       // IP header flags (usually 0)
    unsigned char      OptionsSize; // Size of options data (usually 0, max 40)
    unsigned char FAR* OptionsData; // Options data buffer
} IPINFO, *PIPINFO, FAR *LPIPINFO;

//----------------------------------------------------------------------------
// *** Note 1 ***
// The Reply Buffer will have an array of ICMP_ECHO_REPLY
// structures, followed by options and the data in ICMP echo reply
// datagram received. You must have room for at least one ICMP
// echo reply structure, plus 8 bytes for an ICMP header. 
//----------------------------------------------------------------------------
typedef struct icmp_echo_reply 
{
    unsigned long                Address;   // source address
    unsigned long                Status;    // IP status value (see below)
    unsigned long                RTTime;    // Round Trip Time in milliseconds
    unsigned short               DataSize;  // reply data size
    unsigned short               Reserved;
    void FAR*                    Data;      // reply data buffer
    struct ip_option_information Options;   // reply options
} ICMPECHO, *PICMPECHO, FAR *LPICMPECHO;


//----------------------------------------------------------------------------
enum ICMP_REQUEST_CLASS
{
    ICMP_REQUEST_CLASS_PING = 0,
    ICMP_REQUEST_CLASS_TRACEROUTE,
    ICMP_REQUEST_CLASS_MAX
};

//----------------------------------------------------------------------------
typedef struct icmp_request
{
    int    RequestClass;
    string Host;
    int    nDataLength;
    int    nLoopLimit;
    int    nTimeout;
    bool   bDontFrag;
    bool   bDebug;
    int    nTTL;
    int    nTOS;
    bool   bRouterAlert;
} ICMP_REQUEST;

//----------------------------------------------------------------------------
typedef list<string> ICMP_HOP_LIST;

//----------------------------------------------------------------------------
typedef struct icmp_result
{
    int           RequestClass;
    string        Host;
    DWORD         AverageTime;
    DWORD         BytesTransferred;
    ICMP_HOP_LIST HopList;
} ICMP_RESULT;




class ICMPThread;

//////////////////////////////////////////////////////////////////////////////
// Classname   : ICMPRepository
// Description : 
//////////////////////////////////////////////////////////////////////////////

class ICMPRepository : public Singleton<ICMPRepository>
{
private:
    typedef list<ICMP_REQUEST*>            REQUEST_LIST;
    typedef hash_map<string, ICMP_RESULT*> RESULT_MAP;


private:
    REQUEST_LIST             m_RequestList;
    RESULT_MAP               m_ResultMap;
    mutable CriticalSection  m_RequestCS;
    mutable CriticalSection  m_ResultCS;

    ICMPThread**             m_ppICMPThreads;
    int                      m_ICMPThreadCount;


public:
    ICMPRepository();
    ~ICMPRepository();


public:
    // ICMP operation 요청을 큐에다 집어넣는다.
    // 기본 옵션을 사용해서 요청을 할 때 쓰이는 함수다.
    void enqueueRequest(const string& host, int request);

    // ICMP operation 요청을 큐에다 집어넣는다.
    // 기본 옵션을 오버라이드해서 요청을 하고자할 때 쓰이는 함수다.
    void enqueueRequest(ICMP_REQUEST* pRequest);

    // ICMP operation 요청을 큐에서 꺼낸다.
    // 큐에 아무 것도 없을 경우 NULL을 리턴한다.
    ICMP_REQUEST* dequeueRequest();

    // operation 결과 정보를 맵에서 찾아서 리턴한다. 없으면 NULL을 리턴
    ICMP_RESULT* getResult(const string& host) const;

    // operation 결과 정보를 맵에다 추가한다. 이미 있을 경우 어서트!
    void addResult(ICMP_RESULT* pResult);

    // 해당하는 operation 결과 정보를 맵에서 삭제한다. 없을 경우 어서트
    void deleteResult(const string& host);
};

// global varible
#define g_pICMPRepository ICMPRepository::instance()



//////////////////////////////////////////////////////////////////////////////
// Classname   : ICMPThread
// Description : 
//////////////////////////////////////////////////////////////////////////////

class ICMPThread : public Thread
{
friend class ICMPRepository;


private:
    typedef HANDLE (CALLBACK *PROC_ICMP_CREATE_FILE)(VOID);
    typedef BOOL (CALLBACK *PROC_ICMP_CLOSE_HANDLE)(HANDLE ICMPHandle);
    typedef DWORD (CALLBACK *PROC_ICMP_SEND_ECHO)(HANDLE IcmpHandle, unsigned long DestAddress, LPVOID RequestData, WORD RequestSize, LPIPINFO RequestOptns, LPVOID ReplyBuffer, DWORD ReplySize, DWORD Timeout);


private:
    bool                   m_bContinue;
    HMODULE                m_hICMPDLL;
    HANDLE                 m_hICMP;
    PROC_ICMP_CREATE_FILE  m_pfnIcmpCreateFile;
    PROC_ICMP_CLOSE_HANDLE m_pfnIcmpCloseHandle;
    PROC_ICMP_SEND_ECHO    m_pfnIcmpSendEcho;
    char*                  m_pRequestData;
    char*                  m_pReplyData;
    int                    m_DataBufferSize;


public:
    ICMPThread();
    ~ICMPThread();


public:
    // 쓰레드에서 독립적으로 실행되는 코드가 들어가는 부분이다. Thread 클래스를 
    // 상속받은 하위 클래스는 항상 이 함수를 재정의해줘야 한다.
    DWORD run();

    // 쓰레드 함수를 완전히 종료시킨다. 
    // 이 method를 부른 뒤에는 쓰레드를 재실행시킬 수 없다.
    void stop();


private:
    // ping을 시도한다.
    void ping(ICMP_REQUEST* pRequest, ICMP_RESULT* pResult);

    // traceroute를 시도한다.
    void traceroute(ICMP_REQUEST* pRequest, ICMP_RESULT* pResult);

    // 기존의 데이터 버퍼를 삭제하고, 새로운 데이터 버퍼를 생성한다.
    void resizeDataBuffer(int NewDataLength);

    // 에러 코드를 문자열로 바꿔서 화면에 출력한다.
    void outputError(int nICMPError) const;
};


#endif //__ICMPREPOSITORY_H__





2.3 ICMPRepository.cpp

#include "ICMPRepository.h"
#include "FunctionObject.h"
#include "StringStream.h"
#include <iostream>

ICMPRepository::ICMPRepository()
{
    m_ICMPThreadCount = 1;

    m_ppICMPThreads = new ICMPThread*[m_ICMPThreadCount];
    for (int i=0; i<m_ICMPThreadCount; i++)
    {
        m_ppICMPThreads[i] = new ICMPThread();
        m_ppICMPThreads[i]->start(true);
    }
}

ICMPRepository::~ICMPRepository()
{
    for (int i=0; i<m_ICMPThreadCount; i++)
    {
        m_ppICMPThreads[i]->stop();
        Sleep(1000);
        delete m_ppICMPThreads[i];
    }

    delete [] m_ppICMPThreads;

    DESTROY_ALL_OBJECT_1(m_RequestList);
    DESTROY_ALL_OBJECT_2(m_ResultMap);
}

// ICMP operation 요청을 큐에다 집어넣는다.
// 기본 옵션을 사용해서 요청을 할 때 쓰이는 함수다.
void ICMPRepository::enqueueRequest(const string& host, int request)
{
    Assert(!host.empty());
    Assert(request >= 0);
    Assert(request < ICMP_REQUEST_CLASS_MAX);

    __GUARDED_AREA(m_RequestCS);

    // 이미 같은 호스트가 존재하지 않는지 검사한다.
    // 효율성이 의심되는 부분이니 나중에는 빼야한다.
    REQUEST_LIST::const_iterator itr = m_RequestList.begin();
    for (; itr != m_RequestList.end(); itr++)
    {
        ICMP_REQUEST* pRequest = *itr;
        if (host == pRequest->Host)
        {
            Assert(false);
        }
    }

    ICMP_REQUEST* pNewRequest = new ICMP_REQUEST;

    // 기본 옵션을 세팅한다.
    // 기본 옵션 자체를 수정하는 함수를 제공하고 싶기는 하지만, 귀찮다.
    pNewRequest->RequestClass = request;
    pNewRequest->Host         = host;
    pNewRequest->nDataLength  = 8192;
    pNewRequest->nLoopLimit   = 4;
    pNewRequest->nTimeout     = 5000;
    pNewRequest->bDontFrag    = false;
    pNewRequest->bDebug       = false;
    pNewRequest->nTTL         = 64;
    pNewRequest->nTOS         = 0;
    pNewRequest->bRouterAlert = false;

    m_RequestList.push_back(pNewRequest);
}

// ICMP operation 요청을 큐에다 집어넣는다.
// 기본 옵션을 오버라이드해서 요청을 하고자할 때 쓰이는 함수다.
void ICMPRepository::enqueueRequest(ICMP_REQUEST* pRequest)
{
    Assert(!(pRequest->Host.empty()));
    Assert(pRequest->RequestClass >= 0);
    Assert(pRequest->RequestClass < ICMP_REQUEST_CLASS_MAX);

    __GUARDED_AREA(m_RequestCS);

    // 이미 같은 호스트가 존재하지 않는지 검사한다.
    // 효율성이 의심되는 부분이니 나중에는 빼야한다.
    REQUEST_LIST::const_iterator itr = m_RequestList.begin();
    for (; itr != m_RequestList.end(); itr++)
    {
        ICMP_REQUEST* pPrevRequest = *itr;
        if (pRequest->Host == pPrevRequest->Host)
        {
            Assert(false);
        }
    }

    // 이 부분에 함수 인자를 조사할 필요가 있을 듯한데...

    m_RequestList.push_back(pRequest);
}

// ICMP operation 요청을 큐에서 꺼낸다.
// 큐에 아무 것도 없을 경우 NULL을 리턴한다.
ICMP_REQUEST* ICMPRepository::dequeueRequest()
{
    __GUARDED_AREA(m_RequestCS);

    if (m_RequestList.empty()) return NULL;

    ICMP_REQUEST* pRequest = m_RequestList.front();
    m_RequestList.pop_front();
    return pRequest;
}

// operation 결과 정보를 맵에서 찾아서 리턴한다. 없으면 NULL을 리턴
ICMP_RESULT* ICMPRepository::getResult(const string& host) const
{
    __GUARDED_AREA(m_ResultCS);

    RESULT_MAP::const_iterator itr = m_ResultMap.find(host);
    if (itr != m_ResultMap.end())
    {
        return itr->second;
    }

    return NULL;
}

// operation 결과 정보를 맵에다 추가한다. 이미 있을 경우 어서트!
void ICMPRepository::addResult(ICMP_RESULT* pResult)
{
    __GUARDED_AREA(m_ResultCS);

    RESULT_MAP::const_iterator itr = m_ResultMap.find(pResult->Host);
    if  (itr == m_ResultMap.end())
    {
        m_ResultMap.insert(RESULT_MAP::value_type(pResult->Host, pResult));
    }
    else
    {
        NEVER_GET_HERE;
    }
}

// 해당하는 operation 결과 정보를 맵에서 삭제한다. 없을 경우 어서트
void ICMPRepository::deleteResult(const string& host)
{
    __GUARDED_AREA(m_ResultCS);

    RESULT_MAP::iterator itr = m_ResultMap.find(host);
    if (itr != m_ResultMap.end())
    {
        SAFE_DELETE(itr->second);
        m_ResultMap.erase(itr);
    }
    else
    {
        NEVER_GET_HERE;
    }
}



ICMPThread::ICMPThread()
: Thread()
{
    m_bContinue         = true;
    m_DataBufferSize    = 0;
    m_pRequestData      = NULL;
    m_pReplyData        = NULL;

    // Load the ICMP.DLL
    m_hICMPDLL = ::LoadLibrary("ICMP.DLL");
    if (m_hICMPDLL == 0) 
    {
        printError("Unable to locate ICMP.DLL!");
        NEVER_GET_HERE;
    }

    // Get pointers to ICMP.DLL functions
    m_pfnIcmpCreateFile  = (PROC_ICMP_CREATE_FILE)GetProcAddress(m_hICMPDLL,"IcmpCreateFile");
    m_pfnIcmpCloseHandle = (PROC_ICMP_CLOSE_HANDLE)GetProcAddress(m_hICMPDLL,"IcmpCloseHandle");
    m_pfnIcmpSendEcho    = (PROC_ICMP_SEND_ECHO)GetProcAddress(m_hICMPDLL,"IcmpSendEcho");

    if (!m_pfnIcmpCreateFile || !m_pfnIcmpCloseHandle || !m_pfnIcmpSendEcho) 
    {
        printError("failed to get at least one function.");
        NEVER_GET_HERE;
    }

    m_hICMP = (HANDLE)m_pfnIcmpCreateFile();
    Assert(m_hICMP != INVALID_HANDLE_VALUE);

    resizeDataBuffer(8192);
}

ICMPThread::~ICMPThread()
{
    SAFE_DELETE_ARRAY(m_pRequestData);
    SAFE_DELETE_ARRAY(m_pReplyData);

    if (!m_pfnIcmpCloseHandle(m_hICMP))
    {
        NEVER_GET_HERE;
    }

    // Shut down...
    ::FreeLibrary(m_hICMPDLL);
}

// 쓰레드에서 독립적으로 실행되는 코드가 들어가는 부분이다. Thread 클래스를 
// 상속받은 하위 클래스는 항상 이 함수를 재정의해줘야 한다.
DWORD ICMPThread::run()
{
    while (m_bContinue)
    {
        ICMP_REQUEST* pRequest = g_pICMPRepository->dequeueRequest();
        if (pRequest == NULL)
        {
            Sleep(1000);
            continue;
        }

        ICMP_RESULT* pResult = new ICMP_RESULT;

        pResult->RequestClass     = pRequest->RequestClass;
        pResult->Host             = pRequest->Host;
        pResult->AverageTime      = 0;
        pResult->BytesTransferred = 0;

        if (pRequest->RequestClass == ICMP_REQUEST_CLASS_PING)
        {
            ping(pRequest, pResult);
        }
        else if (pRequest->RequestClass == ICMP_REQUEST_CLASS_TRACEROUTE)
        {
            traceroute(pRequest, pResult);
        }
        else
        {
            NEVER_GET_HERE;
        }

        // 결과값을 추가하고...
        g_pICMPRepository->addResult(pResult);

        // 요청 정보를 삭제한다.
        SAFE_DELETE(pRequest);
    }

    return 0;
}

// 쓰레드 함수를 완전히 종료시킨다. 
// 이 method를 부른 뒤에는 쓰레드를 재실행시킬 수 없다.
void ICMPThread::stop()
{
    m_bContinue = false;
}

void ICMPThread::ping(ICMP_REQUEST* pRequest, ICMP_RESULT* pResult)
{
    IPINFO stIPInfo;
    IN_ADDR stDestAddr;

    // Is the string an address?
    stDestAddr.s_addr = inet_addr(pResult->Host.c_str());
    Assert(stDestAddr.s_addr != INADDR_NONE);

    if (pRequest->nDataLength > m_DataBufferSize)
    {
        resizeDataBuffer(pRequest->nDataLength);
    }

    // Init data buffer printable ASCII, 32 (space) through 126 (tilde)
    for (int j=0, i=32; j<pRequest->nDataLength; j++, i++) 
    {
        if (i>=126) i= 32;
        m_pRequestData[j] = i;
    }
     
    // Init IPInfo structure
    stIPInfo.TTL   = pRequest->nTTL;
    stIPInfo.TOS   = pRequest->nTOS;
    stIPInfo.Flags = pRequest->bDontFrag ? IPFLAG_DONT_FRAGMENT : 0;
    if (pRequest->bRouterAlert) 
    {
        // Works if IP Flags NOT set
        DWORD dwIPOption = htonl(IPOPT_ROUTER_ALERT); 

        stIPInfo.OptionsSize = sizeof(dwIPOption);
        stIPInfo.OptionsData = (unsigned char*)&dwIPOption;
    } 
    else 
    {
        stIPInfo.OptionsSize = 0;
        stIPInfo.OptionsData = NULL;
    }

    // Ping Loop
    for (int k=0; k<pRequest->nLoopLimit; k++) 
    {
        // Send the ICMP Echo Request and read the Reply
        DWORD dwReplyCount = m_pfnIcmpSendEcho(
            m_hICMP, 
            stDestAddr.s_addr,
            m_pRequestData,
            pRequest->nDataLength,
            &stIPInfo, 
            m_pReplyData, 
            sizeof(ICMPECHO) + m_DataBufferSize,
            pRequest->nTimeout);

        if (dwReplyCount != 0) 
        {
            IN_ADDR stDestAddr;
            DWORD   dwStatus;

            stDestAddr.s_addr = *(DWORD*)m_pReplyData;

            // Reply from         %s : inet_ntoa(stDestAddr)
            // Bytes Transferred  %d : *(DWORD*)&(m_pReplyData[12])
            // Time (millisecond) %d : *(DWORD*)&(m_pReplyData[8])
            // TTL                %d : (*(char*)&(m_pReplyData[20])) & 0x00FF
            pResult->BytesTransferred += *(DWORD*)&(m_pReplyData[12]);
            pResult->AverageTime      += *(DWORD*)&(m_pReplyData[8]);

            dwStatus = *(DWORD*)&(m_pReplyData[4]);
            if (dwStatus != IP_SUCCESS) 
            {
                outputError(dwStatus);
            } 
        } 
        else 
        {
            outputError(GetLastError());
            break;
        }
    }

    pResult->AverageTime = pResult->AverageTime / pRequest->nLoopLimit;
}

void ICMPThread::traceroute(ICMP_REQUEST* pRequest, ICMP_RESULT* pResult)
{
    IPINFO stIPInfo;
    IN_ADDR stDestAddr;

    // Is the string an address?
    stDestAddr.s_addr = inet_addr(pResult->Host.c_str());
    Assert(stDestAddr.s_addr != INADDR_NONE);

    if (pRequest->nDataLength > m_DataBufferSize)
    {
        resizeDataBuffer(pRequest->nDataLength);
    }

    // Init data buffer printable ASCII, 32 (space) through 126 (tilde)
    for (int j=0, i=32; j<pRequest->nDataLength; j++, i++) 
    {
        if (i>=126) i= 32;
        m_pRequestData[j] = i;
    }
     
    // Init IPInfo structure
    // traceroute를 할 때는 TTL은 반드시 0이어야한다.
    stIPInfo.TTL   = 0;
    stIPInfo.TOS   = pRequest->nTOS;
    stIPInfo.Flags = pRequest->bDontFrag ? IPFLAG_DONT_FRAGMENT : 0;
    if (pRequest->bRouterAlert) 
    {
        // Works if IP Flags NOT set
        DWORD dwIPOption = htonl(IPOPT_ROUTER_ALERT); 

        stIPInfo.OptionsSize = sizeof(dwIPOption);
        stIPInfo.OptionsData = (unsigned char*)&dwIPOption;
    } 
    else 
    {
        stIPInfo.OptionsSize = 0;
        stIPInfo.OptionsData = NULL;
    }

    // traceroute loop
    while (true)
    {
        // increase IP Time To Live
        ++stIPInfo.TTL;

        // Send the ICMP Echo Request and read the Reply
        DWORD dwReplyCount = m_pfnIcmpSendEcho(m_hICMP, 
            stDestAddr.s_addr,
            m_pRequestData,
            pRequest->nDataLength,
            &stIPInfo, 
            m_pReplyData, 
            sizeof(ICMPECHO) + m_DataBufferSize, 
            pRequest->nTimeout);

        if (dwReplyCount != 0) 
        {
            IN_ADDR stDestAddr;
            DWORD   dwStatus;

            stDestAddr.s_addr = *(DWORD *)m_pReplyData;

            // Reply from         %s : inet_ntoa(stDestAddr)
            // Bytes Transferred  %d : *(DWORD*)&(m_pReplyData[12])
            // Time (millisecond) %d : *(DWORD*)&(m_pReplyData[8])
            // TTL                %d : (*(char*)&(m_pReplyData[20])) & 0x00FF
            pResult->HopList.push_back(string(inet_ntoa(stDestAddr)));

            dwStatus = *(DWORD*)&(m_pReplyData[4]);

            if (dwStatus == IP_SUCCESS) 
            {
                // We're done, since we reached the destination!
                break;  
            } 
        } 
        else 
        {
            outputError(::GetLastError());
        }
    }
}

// 기존의 데이터 버퍼를 삭제하고, 새로운 데이터 버퍼를 생성한다.
void ICMPThread::resizeDataBuffer(int NewDataLength)
{
    Assert(m_DataBufferSize < NewDataLength);

    SAFE_DELETE_ARRAY(m_pRequestData);
    SAFE_DELETE_ARRAY(m_pReplyData);

    m_DataBufferSize = NewDataLength;

    m_pRequestData = new char[m_DataBufferSize];
    m_pReplyData = new char[sizeof(ICMPECHO) + m_DataBufferSize];
}

// 에러 코드를 문자열로 바꿔서 화면에 출력한다.
void ICMPThread::outputError(int nICMPErr) const
{
    int nErrIndex = nICMPErr - IP_STATUS_BASE;
    if (ID2String(ICMPStatus2String, nErrIndex) == NULL)
    {
        cerr << "(" << nICMPErr << ") " << convertErrorToString(nICMPErr) << endl;
    }
    else
    {
        cerr << ID2String(ICMPStatus2String, nErrIndex) << endl;
    }
}

3 Ping Implementation

3.1 Microsoft ICMP Library Version

Microsoft ICMP 라이브러리를 사용한 Ping 예제이다.



3.1.1 PingI.c

//
// PingI.c -- Simple ping program using the proprietary 
//            Microsoft ICMP API
//
 
#include <windows.h>
#include <winsock.h>
#include <stdio.h>
#include <string.h>

typedef struct tagIPINFO
{
    u_char Ttl;             // Time To Live
    u_char Tos;             // Type Of Service
    u_char IPFlags;         // IP flags
    u_char OptSize;         // Size of options data
    u_char FAR *Options;    // Options data buffer
}IPINFO, *PIPINFO;

typedef struct tagICMPECHO
{
    u_long Source;          // Source address
    u_long Status;          // IP status
    u_long RTTime;          // Round trip time in milliseconds
    u_short DataSize;       // Reply data size
    u_short Reserved;       // Unknown
    void FAR *pData;        // Reply data buffer
    IPINFO  ipInfo;         // Reply options
}ICMPECHO, *PICMPECHO;


// ICMP.DLL Export Function Pointers
HANDLE (WINAPI *pIcmpCreateFile)(VOID);
BOOL (WINAPI *pIcmpCloseHandle)(HANDLE);
DWORD (WINAPI *pIcmpSendEcho)
    (HANDLE,DWORD,LPVOID,WORD,PIPINFO,LPVOID,DWORD,DWORD);

//
//
void main(int argc, char **argv)
{
    WSADATA wsaData;            // WSADATA
    ICMPECHO icmpEcho;          // ICMP Echo reply buffer
    HANDLE hndlIcmp;            // LoadLibrary() handle to ICMP.DLL
    HANDLE hndlFile;            // Handle for IcmpCreateFile()
    LPHOSTENT pHost;            // Pointer to host entry structure
    struct in_addr iaDest;      // Internet address structure
    DWORD *dwAddress;           // IP Address
    IPINFO ipInfo;              // IP Options structure
    int nRet;                   // General use return code
    DWORD dwRet;                // DWORD return code
    int x;

    // Check arguments
    if (argc != 2)
    {
        fprintf(stderr,"\nSyntax: pingi HostNameOrIPAddress\n");
        return;
    }

    // Dynamically load the ICMP.DLL
    hndlIcmp = LoadLibrary("ICMP.DLL");
    if (hndlIcmp == NULL)
    {
        fprintf(stderr,"\nCould not load ICMP.DLL\n");
        return;
    }
    // Retrieve ICMP function pointers<