TnbDialupManager.h

[詳解]

#pragma once
#include "TnbStrVector.h"
#include "TnbStrEx.h"
#include "TnbMap.h"
#include "TnbThread.h"
#include "TnbStaticMap.h"
#include <Ras.h>
#include <RasError.h>
#ifndef _WIN32_WCE
 #include "TnbRegistryAccessor.h"
 #pragma comment(lib,"RasApi32.lib")
 #if ( WINVER >= 0x500 )
   #ifndef RASEAPINFO
    #error 
    // WINVER 0x0500 以上の場合、VC6++ 付属の RAS.h は使用できません（バグ）
    // SDK のRAS.h をインクルードするようにしてください。
    //（ｵﾌﾟｼｮﾝ→ﾃﾞｨﾚｸﾄﾘで SDKのヘッダのほうが先になるようにする、など）。
   #endif
 #endif
#endif
 
 
 
//TNB Library
namespace TNB
{
 
 
 
#define _DIALUP_TRACE(FUNC, VAL) \
    if ( (VAL) != 0 ) { TRACE3("%s failed: Error %u[%s]\n", _T(#FUNC), VAL, GetErrorString(VAL)); }
 
 
 
class CDialupManager : TNB::CThread::IRunner, CCopyImpossible
{
public:
 
    struct IListener
    {
        virtual ~IListener(void) {}
 
        virtual void OnDialupError(DWORD dwError) = 0;
 
        virtual void OnDialupChangeState(RASCONNSTATE eState) = 0;
 
    private:
        friend class CDialupManager;        
    };
 
private:
 
    CThread             m_threadWatch;  
    IListener*          m_piListener;   
    HRASCONN            m_hRasConn;     
    CSyncSection        m_syncFunc;     
    enum
    {
        E_ConnectCheckInterval = 100,   
        E_DisconnectCheckInterval = 500,
    };
 
    struct TRasConn
    {
        DWORD       dwSize;                                 
        HRASCONN    hRasConn;                               
        TCHAR       szEntryName[RAS_MaxEntryName + 1];      
        #ifndef _WIN32_WCE
        TCHAR       szDeviceType[RAS_MaxDeviceType + 1];    
        TCHAR       szDeviceName[RAS_MaxDeviceName + 1];    
        TCHAR       szPhonebook[MAX_PATH];                  
        DWORD       dwSubEntry;                             
        #endif
        operator LPRASCONN(){ return reinterpret_cast<LPRASCONN>(this); }
        bool IsPhoneBookEqual(CStr& s) const
        {
            #ifndef _WIN32_WCE
                return (s.IsEmpty() || STRLIB::Compare(szPhonebook, s) == 0);
            #else
                return s.IsEmpty();
            #endif
        }
 
    };
 
    typedef CVectorT<TRasConn> CRasConnVector;
 
    static CRasConnVector ms_GetConnectingEnties(void)
    {
        CRasConnVector aRasConn;
        CByteVector ba;
        TRasConn* P = reinterpret_cast<TRasConn*>(ba.GetBuffer(sizeof(TRasConn)));
        P->dwSize = sizeof(TRasConn);
        DWORD dwBufferSize = sizeof(TRasConn);
        DWORD dwEntries = 0;
        DWORD dwRc = ::RasEnumConnections(*P, &dwBufferSize, &dwEntries);
        if ( dwRc == ERROR_BUFFER_TOO_SMALL )
        {
            P = reinterpret_cast<TRasConn*>(ba.GetBuffer(dwBufferSize));
            P->dwSize = sizeof(TRasConn);
            dwRc = ::RasEnumConnections(*P, &dwBufferSize, &dwEntries);
        }
        if ( dwRc != ERROR_SUCCESS )
        {
            _DIALUP_TRACE(RasEnumConnections, dwRc);
            aRasConn.Invalid();
            return aRasConn;
        }
        else
        {
            loop ( i, dwEntries )
            {
                aRasConn.Add(P[i]);
            }
        }
        return aRasConn;
    }
 
    typedef CMapT<HRASCONN, CDialupManager*> CHndThisMap;
 
    void m_ClearHandleRasConn(void)
    {
        if ( m_hRasConn != NULL )
        {
            ms_ElementMap().RemoveKey(m_hRasConn);
            m_hRasConn = NULL;
        }
    }
 
    static CHndThisMap& ms_ElementMap(void)
    {
        static CHndThisMap s_mapHndThis;
        return s_mapHndThis;
    }
 
    static VOID WINAPI 
    ms_RasDialFunc1(HRASCONN h, UINT uMsg, RASCONNSTATE state, DWORD dwError, DWORD dwExError)
    {
        if ( dwError != 0 )
        {
            TRACE3("RasDialFunc s=%d e=%u[%s]\n", state, dwError, GetErrorString(dwError));
            CDialupManager* P;
            if ( ms_ElementMap().Lookup(h, P) != 0 )
            {
                //発見
                if ( (reinterpret_cast<ULONG_PTR>(P) & 0x80000000) == 0 )
                {
                    if ( P->m_piListener != NULL )
                    {
                        if ( P->m_threadWatch.IsAlive() )
                        {
                            P->m_piListener->OnDialupError(dwError);
                        }
                    }
                    P->HangUp();
                }
            }
            else
            {
                ms_ElementMap()[h] = reinterpret_cast<CDialupManager*>(static_cast<size_t>(dwError | 0x80000000));
            }
        }
    }
 
    virtual DWORD Run(void)
    {
        DWORD dwRc;
        RASCONNSTATUS tStatus;
        RASCONNSTATE eNowState = static_cast<RASCONNSTATE>(0xFFFF);
        //
        m_piListener->OnDialupChangeState(RASCS_OpenPort);
        //
        bool boIsFirst = true;
        while ( IsRunnable() )
        {
            ::Sleep(E_ConnectCheckInterval);
            dwRc = GetConnectStatus(tStatus);
            if ( dwRc != NULL )
            {
                //エラー処理はms_RasDialFunc1()で行っています。
                if ( dwRc == ERROR_INVALID_HANDLE )
                {
                    ::Sleep(500);
                    continue;
                }
                break;
            }
            if ( tStatus.dwError != 0 )
            {
                //エラー処理はms_RasDialFunc1()で行っています。
                break;
            }
            //
            if ( boIsFirst )
            {
                boIsFirst = false;
                eNowState = tStatus.rasconnstate;
                TRACE1("ChangeState =[%s]\n", StateToString(eNowState));
                m_piListener->OnDialupChangeState(eNowState);
            }
            else if ( eNowState != tStatus.rasconnstate )
            {
                eNowState = tStatus.rasconnstate;
                TRACE1("ChangeState =[%s]\n", StateToString(eNowState));
                m_piListener->OnDialupChangeState(eNowState);
            }
            //
            if ( eNowState == RASCS_Connected )
            {
                while ( IsRunnable() )
                {
                    dwRc = GetConnectStatus(tStatus);
                    if ( dwRc != NULL || tStatus.rasconnstate == RASCS_Disconnected )
                    {
                        //切断された
                        TRACE1("ChangeState =[%s]\n", StateToString(tStatus.rasconnstate));
                        m_ClearHandleRasConn();
                        m_piListener->OnDialupChangeState(RASCS_Disconnected);
                        break;
                    }
                    ::Sleep(E_DisconnectCheckInterval);
                }
                break;
            }
            if ( eNowState == RASCS_Disconnected )
            {
                m_ClearHandleRasConn();
                break;
            }
        }
        return 0;
    }
 
    static void ms_CheckPhoneBook(LPCTSTR& _lpszPhoneBook)
    {
        if ( _lpszPhoneBook != NULL && _lpszPhoneBook[0] == '\0' )
        {
            _lpszPhoneBook = NULL;
        }
    }
 
    #ifndef _WIN32_WCE
        static LPCTSTR NcStr(LPCTSTR lpsz) { return lpsz; } 
    #else
        class NcStr
        {
            CStr m_str;
            bool m_isNull;
        public:
            NcStr(LPCTSTR lpsz) : m_str(lpsz), m_isNull(lpsz == NULL) {}
            operator LPTSTR(void) { return m_isNull ? NULL : m_str.GetBuffer(256); }
        };
    #endif //_WIN32_WCE
 
public:
 
    struct TDialParams
    {
        CStr strPhoneBook;      
        CStr strEntryName;      
        CStr strUserName;       
        CStr strPassword;       
        CStr strPhoneNumber;    
        CStr strDeviceName;     
        #ifndef _WIN32_WCE
        LPCTSTR GetPhoneBook(void) const
        {
            if ( strPhoneBook.IsEmpty() )
            {
                return NULL;
            }
            return strPhoneBook;
        }
        #else
        LPWSTR GetPhoneBook(void) const { return NULL; }
        #endif
        bool IsInvalid(void) const
        {
            return strEntryName.IsEmpty();
        }
    };
 
    CDialupManager(void) : m_piListener(NULL), m_hRasConn(NULL)
    {
        m_threadWatch.SetRunner(this);
    }
 
    virtual ~CDialupManager(void)
    {
        m_ClearHandleRasConn();
    }
 
    bool IsAttach(void) const
    {
        return m_hRasConn != NULL;
    }
 
    bool Attach(LPCTSTR lpszPhoneBook, LPCTSTR lpszEntryName, IListener* piDialupListener = NULL)
    {
        EXCLUSIVE(&m_syncFunc);
        ms_CheckPhoneBook(lpszPhoneBook);
        Detach();
        HRASCONN hRasConn = GetRasConn(lpszPhoneBook, lpszEntryName);
        if ( hRasConn != NULL )
        {
            //発見
            m_hRasConn = hRasConn;
            ms_ElementMap()[m_hRasConn] = this;
            m_piListener = piDialupListener;
            if ( piDialupListener != NULL )
            {
                #ifdef _DEBUG
                    m_threadWatch.Start(CStr(lpszEntryName) + _T("Dialup"));
                #else
                    m_threadWatch.Start();
                #endif
            }
            return true;
        }
        return false;
    }
 
    DWORD Dial(const TDialParams& D, IListener* piDialupListener = NULL)
    {
        EXCLUSIVE(&m_syncFunc);
        if ( D.IsInvalid() )
        {
            TRACE0("Dial パラメータ異常\n");
            return ERROR_INVALID_PARAMETER;
        }
        //==アタッチしていたらデタッチしておく
        Detach();
        //==デバイス指定
        DWORD dwSize = 0;
        ::RasGetEntryProperties(D.GetPhoneBook(), NcStr(D.strEntryName), NULL, &dwSize, NULL, NULL);
        CByteVector ba;
        LPRASENTRY ptEntry = reinterpret_cast<LPRASENTRY>(ba.GetBuffer(dwSize));
        ptEntry->dwSize = dwSize;
        DWORD dwRc = ::RasGetEntryProperties(D.GetPhoneBook(), NcStr(D.strEntryName), ptEntry, &dwSize, NULL, NULL);
        if ( dwRc != 0 )
        {
            _DIALUP_TRACE(RasGetEntryProperties, dwRc);
            return dwRc;
        }
        if ( ! D.strDeviceName.IsEmpty() )
        {
            if ( D.strDeviceName.Compare(ptEntry->szDeviceName) != 0 )
            {
                STRLIB::Copy(ptEntry->szDeviceName, D.strDeviceName);
                dwRc = ::RasSetEntryProperties(D.GetPhoneBook(), NcStr(D.strEntryName), ptEntry, dwSize, NULL, NULL);
                if ( dwRc != 0 )
                {
                    _DIALUP_TRACE(RasSetEntryProperties, dwRc);
                    return dwRc;
                }
            }
        }
        //
        RASDIALPARAMS t;
        t.dwSize = sizeof(RASDIALPARAMS);
        STRLIB::Copy(t.szEntryName, D.strEntryName);
        STRLIB::Copy(t.szUserName, D.strUserName);
        STRLIB::Copy(t.szPassword, D.strPassword);
        STRLIB::Copy(t.szPhoneNumber, D.strPhoneNumber);
        t.szCallbackNumber[0] = '\0';
        t.szDomain[0] = '\0';
        //
        HRASCONN hRasConn = NULL;
        if ( piDialupListener == NULL )
        {
            //===同期
            dwRc = ::RasDial(NULL, D.GetPhoneBook(), &t, 0, NULL, &hRasConn);
        }
        else
        {
            //===非同期
            dwRc = ::RasDial(NULL, D.GetPhoneBook(), &t, 1, ms_RasDialFunc1, &hRasConn);
        }
        if ( dwRc != 0 )
        {
            _DIALUP_TRACE(RasDial, dwRc);
            return dwRc;
        }
        //
        dwRc = ::RasSetEntryDialParams(D.GetPhoneBook(), &t, false);
        if ( dwRc != 0 )
        {
            _DIALUP_TRACE(RasSetEntryDialParams, dwRc);
            HangUp();
            return dwRc;
        }
        //
        m_hRasConn = hRasConn;
        //
        CDialupManager* pMan;
        if ( ms_ElementMap().Lookup(hRasConn, pMan) != 0 )
        {
            DWORD dwError = static_cast<DWORD>(reinterpret_cast<size_t>(pMan));
            ASSERTLIB((dwError & 0x80000000) != 0);
            dwError &= 0x7FFFFFFF;
            _DIALUP_TRACE(RasDial, dwError);
            HangUp();
            return dwError;
        }
        //
        ms_ElementMap()[hRasConn] = this;
        if ( piDialupListener != NULL )
        {
            m_piListener = piDialupListener;
            #ifdef _DEBUG
                m_threadWatch.Start(D.strEntryName + _T("Dialup"));
            #else
                m_threadWatch.Start();
            #endif
        }
        return 0;
    }
 
    void Detach(void)
    {
        EXCLUSIVE(&m_syncFunc);
        if ( m_hRasConn == NULL )
        {
            return;
        }
        m_threadWatch.Stop();
        m_piListener = NULL;
        m_ClearHandleRasConn();
        return;
    }
 
    DWORD HangUp(void)
    {
        EXCLUSIVE(&m_syncFunc);
        if ( m_hRasConn == NULL )
        {
            m_piListener = NULL;
            return 0;
        }
        //
        m_threadWatch.Stop();
        DWORD dwRc = ::RasHangUp(m_hRasConn);
        _DIALUP_TRACE(RasHangUp, dwRc);
        //
        RASCONNSTATUS tStatus;
        while ( true )
        {
            if ( GetConnectStatus(tStatus) == ERROR_INVALID_HANDLE )
            {
                break;
            }
            ::Sleep(10);
        }
        if ( dwRc == ERROR_NO_CONNECTION )
        {
            dwRc = 0;
        }
        m_piListener = NULL;
        m_ClearHandleRasConn();
        return dwRc;
    }
 
    DWORD GetConnectStatus(RASCONNSTATUS& _tStatus) const
    {
        _tStatus.dwSize = sizeof(RASCONNSTATUS);
        DWORD dwRc = ::RasGetConnectStatus(m_hRasConn, &_tStatus);
        _DIALUP_TRACE(RasGetConnectStatus, dwRc);
        return dwRc;
    }
 
    CStr GetConnectedDeviceName(void) const
    {
        CStr str;
        RASCONNSTATUS tStatus;
        DWORD dwRc = GetConnectStatus(tStatus);
        if ( dwRc == 0 )
        {
            str = tStatus.szDeviceName;
        }
        return str;
    }
 
    CStr GetIpAddress(void) const
    {
        return GetIpAddress(m_hRasConn);
    }
 
    operator HRASCONN()
    {
        return m_hRasConn;
    }
    
    CThreadStatus& ReferThreadStatus(void)
    {
        return m_threadWatch;
    }
 
 
    //============================================================================
 
 
    static CStr GetIpAddress(HRASCONN hRasConn)
    {
        RASPPPIP tRasPppIp = { sizeof(RASPPPIP) };
        DWORD dwLen = sizeof(RASPPPIP);
        DWORD dwRc = ::RasGetProjectionInfo(hRasConn, RASP_PppIp, &tRasPppIp, &dwLen);
        _DIALUP_TRACE(RasGetProjectionInfo, dwRc);
        if ( dwRc == 0 )
        {   
            return tRasPppIp.szIpAddress;
        }
        return _T("");
    }
 
    static HRASCONN GetRasConn(LPCTSTR lpszPhoneBook, LPCTSTR lpszEntryname)
    {
        CStr strPb = lpszPhoneBook;
        CRasConnVector aRass = ms_GetConnectingEnties();
        loop ( i, aRass.GetSize() )
        {
            const TRasConn &T = aRass.At(i);
            if ( STRLIB::Compare(T.szEntryName, lpszEntryname) == 0 )
            {
                if ( T.IsPhoneBookEqual(strPb) )
                {
                    //発見
                    HRASCONN hRasComm = T.hRasConn;
                    RASCONNSTATUS tStatus = { sizeof(RASCONNSTATUS) };
                    DWORD dwRc = ::RasGetConnectStatus(hRasComm, &tStatus);
                    _DIALUP_TRACE(RasGetConnectStatus, dwRc);
                    if ( dwRc != 0 || tStatus.rasconnstate != RASCS_Connected )
                    {
                        return NULL;
                    }
                    return hRasComm;
                }
            }
        }
        return NULL;
    }
 
    static CStrVector EnumEntryNames(LPCTSTR lpszPhoneBook)
    {
        ms_CheckPhoneBook(lpszPhoneBook);
        CStrVector vstrNames;
        CByteVector ba;
        LPRASENTRYNAME P = reinterpret_cast<LPRASENTRYNAME>(ba.GetBuffer(sizeof(RASENTRYNAME)));
        P->dwSize = sizeof(RASENTRYNAME);
        DWORD dwBufferSize = sizeof(RASENTRYNAME);
        DWORD dwEntries = 0;
        DWORD dwRc = ::RasEnumEntries(NULL, NcStr(lpszPhoneBook), P, &dwBufferSize, &dwEntries);
        if ( dwRc == ERROR_BUFFER_TOO_SMALL )
        {
            P = reinterpret_cast<LPRASENTRYNAME>(ba.GetBuffer(dwBufferSize));
            P->dwSize = sizeof(RASENTRYNAME);
            dwRc = ::RasEnumEntries(NULL, NcStr(lpszPhoneBook), P, &dwBufferSize, &dwEntries);
        }
        if ( dwRc != ERROR_SUCCESS )
        {
            _DIALUP_TRACE(RasEnumEntries, dwRc);
            vstrNames.Invalid();
            return vstrNames;
        }
        else
        {
            vstrNames.SetIncrementSize(dwEntries);
            loop ( i, dwEntries )
            {
                vstrNames.Add(P->szEntryName);
                P++;
            }
        }
        return vstrNames;
    }
 
    static CStrVector EnumConnectedEntryNames(void)
    {
        CStrVector vstrEntryNames;
        //
        CRasConnVector aRass = ms_GetConnectingEnties();
        if ( ! aRass.IsValid() )
        {
            vstrEntryNames.Invalid();
            return vstrEntryNames;
        }
        size_t iLen = aRass.GetSize();
        vstrEntryNames.SetIncrementSize(iLen);
        loop ( i, iLen )
        {
            vstrEntryNames.Add(aRass.At(i).szEntryName);
        }
        //
        return vstrEntryNames;
    }
 
    static TDialParams GetDialParams(LPCTSTR lpszPhoneBook, LPCTSTR lpszEntryName)
    {
        ms_CheckPhoneBook(lpszPhoneBook);
        TDialParams tRc;
        //
        RASDIALPARAMS tParams = { sizeof(RASDIALPARAMS) };
        STRLIB::Copy(tParams.szEntryName, lpszEntryName);
        //
        BOOL boHasPassword = TRUE;
        DWORD dwParamsRc = ::RasGetEntryDialParams(NcStr(lpszPhoneBook), &tParams, &boHasPassword);
        if ( dwParamsRc != 0 )
        {
            _DIALUP_TRACE(RasGetEntryDialParams, dwParamsRc);
            return tRc;
        }
        //
        DWORD dwSize = 0;
        ::RasGetEntryProperties(NcStr(lpszPhoneBook), NcStr(lpszEntryName), NULL, &dwSize, NULL, NULL);
        CByteVector ba;
        LPRASENTRY ptEntry = reinterpret_cast<LPRASENTRY>(ba.GetBuffer(dwSize));
        ptEntry->dwSize = dwSize;
        DWORD dwPropertyRc = ::RasGetEntryProperties(NcStr(lpszPhoneBook), NcStr(lpszEntryName), ptEntry, &dwSize, NULL, NULL);
        if ( dwPropertyRc != 0 )
        {
            _DIALUP_TRACE(RasGetEntryProperties, dwPropertyRc);
            return tRc;
        }
        //
        tRc.strEntryName    = lpszEntryName;
        tRc.strUserName     = tParams.szUserName;
        if ( boHasPassword )
        {
            tRc.strPassword = tParams.szPassword;
        }
        tRc.strPhoneNumber  = ptEntry->szLocalPhoneNumber;
        tRc.strDeviceName   = ptEntry->szDeviceName;
        tRc.strPhoneBook    = lpszPhoneBook;
        //
        return tRc;
    }
 
    static CStrVector EnumDeviceNames(bool boIsModemOnly = true)
    {
        CStrVector vstrNames;
        CByteVector ba;
        LPRASDEVINFO P = reinterpret_cast<LPRASDEVINFO>(ba.GetBuffer(sizeof(RASDEVINFO)));
        P->dwSize = sizeof(RASDEVINFO);
        DWORD dwBufferSize = sizeof(RASDEVINFO);
        DWORD dwEntries = 0;
        DWORD dwRc = ::RasEnumDevices(P, &dwBufferSize, &dwEntries);
        if ( dwRc == ERROR_BUFFER_TOO_SMALL )
        {
            P = reinterpret_cast<LPRASDEVINFO>(ba.GetBuffer(dwBufferSize));
            P->dwSize = sizeof(RASDEVINFO);
            dwRc = ::RasEnumDevices(P, &dwBufferSize, &dwEntries);
        }
        if ( dwRc != ERROR_SUCCESS)
        {
            _DIALUP_TRACE(RasEnumDevices, dwRc);
            vstrNames.Invalid();
            return vstrNames;
        }
        else
        {
            vstrNames.SetIncrementSize(dwEntries);
            loop ( i, dwEntries )
            {
                if ( ! boIsModemOnly || STRLIB::Compare(P->szDeviceType, RASDT_Modem) == 0)
                {
                    vstrNames.Add(P->szDeviceName);
                }
                P++;
            }
        }
        return vstrNames;
    }
 
    #ifndef _WIN32_WCE
    static int EnumModemPorts(CStrVector& _vstrModemNames)
    {
        OSVERSIONINFO tOsVerInfo = { sizeof(OSVERSIONINFO) };
        ::GetVersionEx(&tOsVerInfo);
        //ＯＳにより取得するレジストリパスが違う
        CStr strModemBase;
        if ( tOsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
        {
            //Windows95/98系
            strModemBase = "SYSTEM\\CurrentControlSet\\Services\\Class\\Modem";
        }
        else
        {
            //WindowsNT系
            strModemBase = "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E96D-E325-11CE-BFC1-08002BE10318}";
        }
        //
        int iFoundItemNumber = 0;
        _vstrModemNames.RemoveAll();
        _vstrModemNames.SetSize(257);
//      CRegistryAccessor regbase(CRegistryAccessor(HKEY_LOCAL_MACHINE)[strModemBase]);
        CRegistryAccessor regbase(CRegistryAccessor(HKEY_LOCAL_MACHINE).GetHandle(strModemBase));
        CStrVector strSecNames = regbase.EnumSectionNames();
        loop ( i, strSecNames.GetSize() )
        {
            CRegistryAccessor::CSection reg =regbase[strSecNames[i]];
            //モデム名取得        //"FriendlyName"のキーだとデバイスマネージャと同じ表記
            CStr strModemName = reg.QueryString(_T("Model"));
            if ( strModemName.IsEmpty() )
            {
                continue;
            }
            //COMポートを取得する
            CStr strPort = reg.QueryString(_T("AttachedTo"));
            if ( strPort.GetLength() < 4 )
            {
                continue;
            }
            int iPort = strPort.ToInt(3);
            if ( iPort < 0 || iPort > 256 )
            {
                continue;
            }
            _vstrModemNames.Set(iPort, strModemName);
            iFoundItemNumber++;
        }
        return iFoundItemNumber;
    }
 
    static int SetUserInitCommand(LPCTSTR lpszModemName, LPCTSTR lpszCommand)
    {
        OSVERSIONINFO tOsVerInfo = { sizeof(OSVERSIONINFO) };
        ::GetVersionEx(&tOsVerInfo);
        //ＯＳにより取得するレジストリパスが違う
        CStr strModemBase;
        if ( tOsVerInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS )
        {
            //Windows95/98系
            strModemBase = "SYSTEM\\CurrentControlSet\\Services\\Class\\Modem";
        }
        else
        {
            //WindowsNT系
            strModemBase = "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E96D-E325-11CE-BFC1-08002BE10318}";
        }
        //
        CRegistryAccessor regbase(CRegistryAccessor(HKEY_LOCAL_MACHINE).GetHandle(strModemBase));
        CStrVector strSecNames = regbase.EnumSectionNames();
        loop ( i, strSecNames.GetSize() )
        {
            CRegistryAccessor::CSection reg =regbase[strSecNames[i]];
            //モデム名取得        //"FriendlyName"のキーだとデバイスマネージャと同じ表記
            CStr strModemName = reg.QueryString(_T("Model"));
            if ( strModemName.IsEqual(lpszModemName) )
            {
                bool r;
                if ( lpszCommand == NULL || lpszCommand[0] == 0 )
                {
                    r = reg.DeleteKey(_T("UserInit"));
                }
                else
                {
                    r = reg.WriteString(_T("UserInit"), lpszCommand);
                }
                return r;
            }
        }
        return false;
    }
    #endif //_WIN32_WCE
 
    static bool CreatePhoneBookEntry(
                LPCTSTR lpszPhoneBook,
                LPCTSTR lpszEntryName,
                LPCTSTR lpszDeviceName,
                LPCTSTR lpszAreaCode,
                LPCTSTR lpszPhoneNumber,
                LPCTSTR lpszUserName,
                LPCTSTR lpszPassword )
    {
        if ( lpszPhoneBook != NULL && lpszPhoneBook[0] == '\0' )
        {
            lpszPhoneBook = NULL;
        }
        // RASENTRY 構造体のサイズ
        RASENTRY rasEntry = { sizeof(RASENTRY) };
        rasEntry.dwfOptions =
                // DNSを使用する
                RASEO_SpecificNameServers
                //　リモートデフォルトゲートウェイ
                | RASEO_RemoteDefaultGateway;
        //
        CStr strAreaCode = lpszAreaCode;
        if ( ! strAreaCode.IsEmpty() )
        {
            // 市外ダイアルを使用する
            rasEntry.dwfOptions |= RASEO_UseCountryAndAreaCodes;
        }
        rasEntry.dwfOptions = 0x38010118;   //なんでしたっけ？
        //
        rasEntry.dwCountryID            = 81;
        rasEntry.dwCountryCode          = 81;
        rasEntry.dwfNetProtocols        = RASNP_Ip;
        rasEntry.dwFramingProtocol      = RASFP_Ppp;
        _tcsncpy(rasEntry.szAreaCode, strAreaCode, sizeof(rasEntry.szAreaCode) - 1);
        _tcsncpy(rasEntry.szLocalPhoneNumber, lpszPhoneNumber, sizeof(rasEntry.szLocalPhoneNumber) - 1);
        _tcsncpy(rasEntry.szDeviceType, RASDT_Modem, sizeof(rasEntry.szDeviceType) - 1);
        _tcsncpy(rasEntry.szDeviceName, lpszDeviceName, sizeof(rasEntry.szDeviceName) - 1);
        DWORD dwError;
        dwError = ::RasSetEntryProperties (NcStr(lpszPhoneBook), NcStr(lpszEntryName), &rasEntry, sizeof(RASENTRY), NULL, NULL);
        if ( dwError != 0 )
        {
            // エラー処理
            return false;
        }
        RASDIALPARAMS   dialParm = {sizeof(RASDIALPARAMS)};
        dialParm.dwSize = sizeof (RASDIALPARAMS);
        _tcsncpy(dialParm.szEntryName, lpszEntryName, sizeof(dialParm.szEntryName) - 1);
        _tcsncpy(dialParm.szUserName, lpszUserName, sizeof(dialParm.szUserName) - 1);
        _tcsncpy(dialParm.szPassword, lpszPassword, sizeof(dialParm.szPassword) - 1);
        //
        dwError = ::RasSetEntryDialParams(NcStr(lpszPhoneBook), &dialParm, FALSE);
        if ( dwError != 0 )
        {
            // エラー処理
            return false;
        }
        return true;
    }
 
    static CStr GetErrorString(DWORD dwError)
    {
        CStr str;
        #ifndef _WIN32_WCE
            ::RasGetErrorString(dwError, str.GetBuffer(256), 256 * sizeof(TCHAR));
            str.ReleaseBuffer();
        #else
            if ( dwError >= 600 && dwError <= 752 )
            {
                str.Format(_T("RASエラー(%d)"), dwError);
            }
        #endif
        if ( str.IsEmpty() )
        {
            str = SystemErrorToMessageText(dwError);
        }
        str.Remove('\n');
        str.Remove('\r');
        return str;
    }
 
    static CStr StateToString(RASCONNSTATE eState)
    {
        const CStaticMapT<RASCONNSTATE, LPCTSTR> map[] =
        {
            {   RASCS_OpenPort              ,_T("ポートを開いています")           },
            {   RASCS_PortOpened            ,_T("ポートを開きました")            },
            {   RASCS_ConnectDevice         ,_T("機器を接続しています")           },
            {   RASCS_DeviceConnected       ,_T("機器を接続しました")            },
            {   RASCS_AllDevicesConnected   ,_T("すべての機器を接続しました")    },
            {   RASCS_Authenticate          ,_T("認証中です")                    },
            {   RASCS_AuthNotify            ,_T("認証を終了しました")            },
            {   RASCS_AuthRetry             ,_T("認証をリトライ中です")           },
            {   RASCS_AuthCallback          ,_T("認証をコールバック中です")     },
            {   RASCS_AuthChangePassword    ,_T("認証パスワードを変更しています")},
            {   RASCS_AuthProject           ,_T("投影の認証中です")             },
            {   RASCS_AuthLinkSpeed         ,_T("接続速度を認証中です")           },
            {   RASCS_AuthAck               ,_T("ACK認証中です")             },
            {   RASCS_ReAuthenticate        ,_T("再認証中です")                   },
            {   RASCS_Authenticated         ,_T("認証が終了しました")            },
            {   RASCS_PrepareForCallback    ,_T("コールバック準備中です")      },
            {   RASCS_WaitForModemReset     ,_T("モデムのリセット待ちです")     },
            {   RASCS_WaitForCallback       ,_T("コールバックの待機中です")     },
            {   RASCS_Projected             ,_T("投影終了しました")             },
        #ifndef _WIN32_WCE
        #if ( WINVER >= 0x400 )
            {   RASCS_StartAuthentication   ,_T("認証を開始します")             },
            {   RASCS_CallbackComplete      ,_T("コールバックが完了しました")    },
            {   RASCS_LogonNetwork          ,_T("ネットワークにログオンしました")},
        #endif
            {   RASCS_SubEntryConnected     ,_T("SubEntryConnected")            },
            {   RASCS_SubEntryDisconnected  ,_T("SubEntryDisconnected")         },
            {   RASCS_Interactive           ,_T("Interactive")                  },
            {   RASCS_RetryAuthentication   ,_T("RetryAuthentication")          },
            {   RASCS_CallbackSetByCaller   ,_T("CallbackSetByCaller")          },
            {   RASCS_PasswordExpired       ,_T("PasswordExpired")              },
        #if ( WINVER >= 0x500 )
            {   RASCS_InvokeEapUI           ,_T("InvokeEapUI")                  },
        #endif
        #endif //_WIN32_WCE
            {   RASCS_Connected             ,_T("接続完了")                     },
            {   RASCS_Disconnected          ,_T("切断完了")                     },
        };
        LPCTSTR P = CStaticMapT<RASCONNSTATE, LPCTSTR>::Find(eState, map);
        return (P != NULL) ? CStr(P) : CStr::Fmt(_T("Unknown State Code [%d]"), eState);
    }
};
 
 
 
#undef _DIALUP_TRACE
 
 
 
}; // TNB
 
 
 
#ifdef _TnbDOXYGEN  //Document作成用シンボル
 
enum RASCONNSTATE
{
    RASCS_OpenPort              ,
    RASCS_PortOpened            ,
    RASCS_ConnectDevice         ,
    RASCS_DeviceConnected       ,
    RASCS_AllDevicesConnected   ,
    RASCS_Authenticate          ,
    RASCS_AuthNotify            ,
    RASCS_AuthRetry             ,
    RASCS_AuthCallback          ,
    RASCS_AuthChangePassword    ,
    RASCS_AuthProject           ,
    RASCS_AuthLinkSpeed         ,
    RASCS_AuthAck               ,
    RASCS_ReAuthenticate        ,
    RASCS_Authenticated         ,
    RASCS_PrepareForCallback    ,
    RASCS_WaitForModemReset     ,
    RASCS_WaitForCallback       ,
    RASCS_Projected             ,
    RASCS_StartAuthentication   ,
    RASCS_CallbackComplete      ,
    RASCS_LogonNetwork          ,
    RASCS_SubEntryConnected     ,
    RASCS_SubEntryDisconnected  ,
    RASCS_Interactive           ,
    RASCS_RetryAuthentication   ,
    RASCS_CallbackSetByCaller   ,
    RASCS_PasswordExpired       ,
    RASCS_InvokeEapUI           ,
    RASCS_Connected             ,
    RASCS_Disconnected          ,
};
 
#endif //_TnbDOXYGEN