TnbDialupWatcher.h

[詳解]

#pragma once
#include "TnbDialupManager.h"
#include "TnbTime.h"
#include "TnbIcmp.h"
#include "TnbIpHelper.h"
 
 
 
//TNB Library
namespace TNB
{
 
 
 
class CDialupWatcher : TNB::CThread::IRunner , CCopyImpossible
{
    typedef CDialupManager __manage;        
    enum
    {
        E_CheckInterval = 500       
    };
public:
 
    struct TConnectInfo
    {
        bool        boIsDoubtfulConnectSpan;
        CSystemTime timeConnectTime;            
        DWORD       dwConnectingSpan;           
        bool        boIsValidIfRow;             
        MIB_IFROW   tMibIfRow;                  
        void Init(void)
        {
            boIsValidIfRow          = false;
            boIsDoubtfulConnectSpan = true;
            timeConnectTime         = CSystemTime::GetCurrent();
            dwConnectingSpan        = 0;
        }
        CSystemTime GetStartTime(void)
        {
            return timeConnectTime;
        }
        CSystemTime GetEndTime(void)
        {
            return timeConnectTime.AddMillSec(dwConnectingSpan);
        }
    };
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnDialConnect(bool boIsDoubtfulConnectSpan) = 0;
 
        virtual void OnDialDisconnect(const TConnectInfo& t) = 0;
    };
 
protected:
 
    CThread         m_threadWatch;      
    CStr            m_strPhoneBook;     
    CStr            m_strEntryName;     
    DWORD           m_dwConnectedTick;  
    HRASCONN        m_hRasConn;         
    INDEX           m_mibIndex;         
    CByteVector     m_vbIfTableTmp;     
    TConnectInfo    m_tInfo;            
    int             m_iCheckInterval;   
    IListener*      m_piListener;       
 
    virtual DWORD Run(void)
    {
        while ( IsRunnable() )
        {
            //==接続監視ループ
            if ( m_hRasConn == NULL )
            {
                while ( IsRunnable() )
                {
                    m_hRasConn = __manage::GetRasConn(m_strPhoneBook, m_strEntryName);
                    if ( m_hRasConn != NULL )
                    {
                        //接続された
                        TRACE1("CDialupWatcher::接続検知[%s]！\n", m_strEntryName);
                        m_tInfo.boIsDoubtfulConnectSpan = false;
                        if ( m_piListener != NULL )
                        {
                            m_piListener->OnDialConnect(false);
                        }
                        break;
                    }
                    ::Sleep(m_iCheckInterval);
                }
                if ( ! IsRunnable() )
                {
                    break;
                }
            }
            //
            m_dwConnectedTick           = ::GetTickCount();
            m_tInfo.timeConnectTime     = CSystemTime::GetCurrent();
            m_tInfo.dwConnectingSpan    = 0;
            CAscii strAddress               = __manage::GetIpAddress(m_hRasConn);
            ASSERTLIB(! strAddress.IsEmpty());
            m_mibIndex = CIpHelper::GetMibIndex(strAddress);
            CIpHelper::GetMibIfRow(m_mibIndex, m_tInfo.tMibIfRow);
            m_tInfo.boIsValidIfRow = true;
            //
            //==切断監視ループ
            RASCONNSTATUS tStatus;
            while ( IsRunnable() )
            {
                ::Sleep(m_iCheckInterval);
                CIpHelper::GetMibIfRow(m_mibIndex, m_tInfo.tMibIfRow);
                m_tInfo.dwConnectingSpan = ::GetTickCount() - m_dwConnectedTick;
                tStatus.dwSize = sizeof(RASCONNSTATUS);
                DWORD dwRc = ::RasGetConnectStatus(m_hRasConn, &tStatus);
                if ( dwRc != 0 || tStatus.rasconnstate == RASCS_Disconnected )
                {
                    //切断された
                    m_hRasConn = NULL;
                    TRACE1("CDialupWatcher::切断検知[%s]！\n", m_strEntryName);
                    TRACE1("   接続時間 = %d秒\n", m_tInfo.dwConnectingSpan / 1000);
                    TRACE1("             (%d分)\n", m_tInfo.dwConnectingSpan / 1000 / 60);
                    TRACE1("   受信Byte = %dbyte\n", m_tInfo.tMibIfRow.dwInOctets);
                    TRACE1("   送信Byte = %dbyte\n", m_tInfo.tMibIfRow.dwOutOctets);
                    if ( m_piListener != NULL )
                    {
                        m_piListener->OnDialDisconnect(m_tInfo);
                    }
                    break;
                }
            }
        }
        m_tInfo.Init();
        return 0;
    }
 
public:
 
    CDialupWatcher(void) :m_iCheckInterval(E_CheckInterval), m_piListener(NULL), m_hRasConn(NULL)
    {
        m_tInfo.Init();
        m_threadWatch.SetRunner(this);
    }
 
    virtual ~CDialupWatcher(void)
    {
        Stop();
    }
 
    void SetListener(IListener* I = NULL)
    {
        m_piListener = I;
    }
 
    bool IsConnect(void)
    {
        return m_hRasConn != NULL;
    }
 
    void ClearConnectInfo(void)
    {
        m_tInfo.Init();
    }
 
    const TConnectInfo& GetConnectInfo(void)
    {
        if ( IsConnect() )
        {   
            CIpHelper::GetMibIfRow(m_mibIndex, m_tInfo.tMibIfRow);
            m_tInfo.dwConnectingSpan = ::GetTickCount() - m_dwConnectedTick;
        }
        return m_tInfo;
    }
 
    DWORD GetConnectSpan(void)
    {
        return GetConnectInfo().dwConnectingSpan;
    }
 
    void Stop(void)
    {
        m_threadWatch.Stop();
        m_strEntryName.Empty();
        m_strPhoneBook.Empty();
        m_hRasConn = NULL;
        m_tInfo.Init();
    }
 
    bool Start(LPCTSTR lpszPhoneBook, LPCTSTR lpszEntryName, int iCheckInterval = E_CheckInterval)
    {
        if ( m_threadWatch.IsAlive() )
        {
            return false;
        }
        __manage::TDialParams tParam = __manage::GetDialParams(lpszPhoneBook, lpszEntryName);
        if ( tParam.IsInvalid() )
        {
            return false;
        }
        m_strPhoneBook = lpszPhoneBook;
        m_strEntryName = lpszEntryName;
        m_tInfo.boIsValidIfRow = false;
        m_hRasConn = __manage::GetRasConn(lpszPhoneBook, lpszEntryName);
        m_tInfo.boIsDoubtfulConnectSpan = (m_hRasConn != NULL);
        if ( m_hRasConn != NULL )
        {
            //接続された
            TRACE1("CDialupWatcher::すでに接続中検知[%s]！\n", m_strEntryName);
            if ( m_piListener != NULL )
            {
                m_piListener->OnDialConnect(true);
            }
        }
        m_iCheckInterval = iCheckInterval;
        #ifdef _DEBUG
            m_threadWatch.Start(CStr::Fmt(_T("<%s>監視"), lpszEntryName));
        #else
            m_threadWatch.Start();
        #endif
        return true;
    }
 
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_threadWatch;
    }
};
 
 
 
}; // TNB