TnbIcmp.h

[詳解]

#pragma once
#include "TnbException.h"
 
 
 
//T-TestCaseコードカバレッジDisable
#pragma comment(user,"T-Coverage Disable")
 
 
 
#ifndef _TnbDOXYGEN //Document作成用シンボル
 
#ifndef _TnbWINSOCK2_ENABLE
 #include <Winsock.h>
 #define SD_BOTH         0x02
 #ifndef _WIN32_WCE
  #pragma comment(lib,"Wsock32.lib")
 #else
  #pragma comment(lib,"Winsock.lib")
 #endif
#else
 #pragma message("message : Winsock2.0 を使用します。")
 #include <Winsock2.h>
 #define _WSPIAPI_COUNTOF
 #include <Ws2Tcpip.h>
 #ifndef _WIN32_WCE
  #pragma comment(lib,"WS2_32.lib")
 #else
  #pragma comment(lib,"WS2.lib")
 #endif
 #include <mswsock.h>
#endif
 
#ifndef _WIN32_WCE
    #define IPAddr ULONG        // An IP address.
    #include <IPEXPORT.H>
  #if 0
    struct IP_OPTION_INFORMATION {
        UCHAR   Ttl;                // Time To Live
        UCHAR   Tos;                // Type Of Service
        UCHAR   Flags;              // IP header flags
        UCHAR   OptionsSize;        // Size in bytes of options data
        PUCHAR  OptionsData;        // Pointer to options data
    };
    struct ICMP_ECHO_REPLY {
        IPAddr  Address;            // Replying address
        ULONG   Status;             // Reply IP_STATUS
        ULONG   RoundTripTime;      // RTT in milliseconds
        USHORT  DataSize;           // Reply data size in bytes
        USHORT  Reserved;           // Reserved for system use
        PVOID   Data;               // Pointer to the reply data
        struct IP_OPTION_INFORMATION Options; // Reply options
    };
  #endif
#else
    #include <Icmpapi.h>
#endif
 
#endif // _TnbDOXYGEN
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CIcmpFunction : CCopyImpossible
{
public:
 
    CIcmpFunction(void) : m_hModule(NULL), m_pCreateFile(NULL), m_pCloseHandle(NULL), m_pSendEcho(NULL)
    {
    }
 
    ~CIcmpFunction(void)
    {
        if ( m_hModule != NULL )
        {
            ::FreeLibrary(m_hModule);
            m_hModule = NULL;
        }
    }
 
    bool HasModule(void) const
    {
        return m_hModule != NULL;
    }
 
    bool LoadModule(void)
    {
        if ( m_hModule != NULL ){ return true; }
        #ifndef _WIN32_WCE
            m_hModule = ::LoadLibraryW(L"ICMP.dll");
        #else
            m_hModule = ::LoadLibraryW(L"Iphlpapi.dll");
        #endif
        if ( m_hModule != NULL )
        {
            m_pCreateFile = reinterpret_cast<P_IcmpCreateFile>(::GetProcAddressA(m_hModule, "IcmpCreateFile"));
            m_pCloseHandle = reinterpret_cast<P_IcmpCloseHandle>(::GetProcAddressA(m_hModule, "IcmpCloseHandle"));
            m_pSendEcho = reinterpret_cast<P_IcmpSendEcho>(::GetProcAddressA(m_hModule, "IcmpSendEcho"));
        }
        return m_pCreateFile != NULL && m_pCloseHandle != NULL && m_pSendEcho != NULL;
    }
 
    HANDLE CreateFile(void)
    {
        if ( m_pCreateFile == NULL ){ throw CNullPointerException(); }
        return m_pCreateFile();
    }
 
    bool CloseHandle(HANDLE hHandle)
    {
        if ( m_pCloseHandle == NULL ){ throw CNullPointerException(); }
        return !! m_pCloseHandle(hHandle);
    }
 
    DWORD SendEcho(
                HANDLE                  icmpHandle,
                IPAddr                  destinationAddress,
                LPVOID                  pRequestData,
                WORD                    requestSize,
                IP_OPTION_INFORMATION*  pRequestOptions,
                LPVOID                  pReplyBuffer,
                DWORD                   replySize,
                DWORD                   timeout )
    {
        if ( m_pSendEcho == NULL ){ throw CNullPointerException(); }
        return m_pSendEcho(
                            icmpHandle,
                            destinationAddress,
                            pRequestData,
                            requestSize,
                            pRequestOptions,
                            pReplyBuffer,
                            replySize,
                            timeout 
        );
    }
 
private:
    typedef HANDLE (WINAPI *P_IcmpCreateFile)(VOID);
    typedef BOOL (WINAPI *P_IcmpCloseHandle)(HANDLE);
    typedef DWORD (WINAPI *P_IcmpSendEcho)(HANDLE, IPAddr, LPVOID, WORD, IP_OPTION_INFORMATION*, void*, DWORD, DWORD);
    HMODULE                 m_hModule;          
    P_IcmpCreateFile        m_pCreateFile;      
    P_IcmpCloseHandle       m_pCloseHandle;     
    P_IcmpSendEcho          m_pSendEcho;        
};
 
 
 
class CPing : CCopyImpossible
{
public:
 
    CPing(void) : m_hPing(INVALID_HANDLE_VALUE), m_buf(BUFFER_LEN)
    {
    }
 
    ~CPing(void)
    {
        Close();
    }
 
    void Close(void)
    {
        if ( m_hPing != INVALID_HANDLE_VALUE )
        {
            m_icmp.CloseHandle(m_hPing);
            m_hPing = INVALID_HANDLE_VALUE;
        }
    }
 
    int Echo(IPAddr ipAddr, DWORD timeout = 1000, int tryCount = 5)
    {
        int r = m_Open();
        if ( r < 0 )
        {
            return r;
        }
        int c = 0;
        loop ( i, tryCount )
        {
            if ( m_SendEcho(ipAddr, timeout) )
            {
                c++;
            }
        }
        return c;
    }
 
private:
    enum 
    {
        BUFFER_LEN = sizeof(ICMP_ECHO_REPLY) + sizeof(DWORD)
    };
    int m_Open(void)
    {
        if ( m_hPing == INVALID_HANDLE_VALUE )
        {
            if ( ! m_icmp.LoadModule() )
            { 
                return -1; //ICMPのハンドルが使用できないエラー。
            }
            m_hPing = m_icmp.CreateFile();
            if ( m_hPing == INVALID_HANDLE_VALUE )
            {
                return -2; //ICMPモジュールが見つからないエラー
            }
        }
        return 0; //成功
    }
    bool m_SendEcho(IPAddr ipAddr, DWORD timeout)
    {
        DWORD dummy;        
        DWORD dwRetVal = m_icmp.SendEcho(
                m_hPing, ipAddr, &dummy, sizeof(DWORD),
                NULL, m_buf.Ref(), BUFFER_LEN, timeout
        );
        return dwRetVal != 0;
    }
    CIcmpFunction   m_icmp;         
    HANDLE          m_hPing;        
    CWorkMemT<char> m_buf;          
};
 
 
 
}; //TNB
 
 
 
//T-TestCaseコードカバレッジEnable
#pragma comment(user,"T-Coverage Enable")