windows-server-2003/base/ntsetup/oobe/msobcomm/msobcomm.cpp

//*********************************************************************
//*                  Microsoft Windows                               **
//*            Copyright(c) Microsoft Corp., 1999                    **
//*********************************************************************
//
//  MSOBCOMM.CPP - Implementation of CObCommunicationManager
//
//  HISTORY:
//
//  1/27/99 a-jaswed Created.
//
//  Class which will manage all communication functions

#include "msobcomm.h"
#include "dispids.h"
#include "CntPoint.h"       // ConnectionPoint Component
#include <ocidl.h>          //For IConnectionPoint and IEnumConnectionPoints
#include <olectl.h>
#include <shlwapi.h>
#include <util.h>
#include "enumodem.h"
#include "commerr.h"
#include "homenet.h"

extern DWORD
IsMouseOrKeyboardPresent(HWND  HWnd,
                         PBOOL pbKeyboardPresent,
                         PBOOL pbMousePresent);

CObCommunicationManager* gpCommMgr    = NULL;

///////////////////////////////////////////////////////////
//
// Creation function used by CFactory.
//
HRESULT CObCommunicationManager::CreateInstance(IUnknown*  pOuterUnknown,
                                                CUnknown** ppNewComponent)
{
   if (pOuterUnknown != NULL)
   {
      // Don't allow aggregation. Just for the heck of it.
      return CLASS_E_NOAGGREGATION;
   }

   *ppNewComponent = new CObCommunicationManager(pOuterUnknown);
   return S_OK;
}

///////////////////////////////////////////////////////////
//
//  NondelegatingQueryInterface
//
HRESULT __stdcall
CObCommunicationManager::NondelegatingQueryInterface(const IID& iid, void** ppv)
{
    if (iid == IID_IObCommunicationManager2 || iid == IID_IObCommunicationManager)
    {
        return FinishQI(static_cast<IObCommunicationManager*>(this), ppv);
    }
    else
    {
        return CUnknown::NondelegatingQueryInterface(iid, ppv);
    }
}

///////////////////////////////////////////////////////////
//
//  Constructor
//
CObCommunicationManager::CObCommunicationManager(IUnknown* pOuterUnknown)
: CUnknown(pOuterUnknown)
{
    m_pConnectionPoint  = NULL;
    m_pWebGate          = NULL;
    m_hwndCallBack      = NULL;
    m_pRefDial          = NULL;
    m_InsHandler        = NULL;
    m_pDisp             = NULL;
    m_IcsMgr            = NULL;
    m_bIsIcsUsed        = FALSE;
    ZeroMemory(m_szExternalConnectoid, sizeof(m_szExternalConnectoid));
    m_bFirewall         = FALSE;

}

///////////////////////////////////////////////////////////
//
//  Destructor
//
CObCommunicationManager::~CObCommunicationManager()
{
    if (m_pDisp)
        m_pDisp->Release();

    if (m_InsHandler)
        delete m_InsHandler;

    if (m_pRefDial)
        delete m_pRefDial;

    if (m_pWebGate)
        delete m_pWebGate;

    if (m_pConnectionPoint)
        delete m_pConnectionPoint;

    if (m_IcsMgr)
        delete m_IcsMgr;
}

///////////////////////////////////////////////////////////
//
//  FinalRelease -- Clean up the aggreated objects.
//
void CObCommunicationManager::FinalRelease()
{
    CUnknown::FinalRelease();
}


///////////////////////////////////////////////////////////
//  IObCommunicationManager Implementation
///////////////////////////////////////////////////////////
INT CObCommunicationManager::m_nNumListener = 0;

///////////////////////////////////////////////////////////
// ListenToCommunicationEvents
HRESULT CObCommunicationManager::ListenToCommunicationEvents(IUnknown* pUnk)
{
    DObCommunicationEvents* pCommEvent = NULL;
    m_pDisp = NULL;

    CObCommunicationManager::m_nNumListener ++;

    //first things first
    if (!pUnk)
        return E_FAIL;

    //So somebody want to register to listen to our ObWebBrowser events
    //Ok, let's get sneaky and reverse QI them to see if they even say they
    //support the right interfaces
    //if (FAILED(pUnk->QueryInterface(DIID_DObCommunicationEvents, (LPVOID*)&pCommEvent)) || !pCommEvent)
    //    return E_UNEXPECTED;

    // ListenToCommunicationEvents treats CConnectionPoint as a C++ object and not like a COM object.
    // Everyone else deals with CConnectionPoint through COM interfaces.
    if (!m_pConnectionPoint)
        m_pConnectionPoint = new CConnectionPoint(this, &IID_IDispatch) ;

    if (FAILED(pUnk->QueryInterface(IID_IDispatch, (LPVOID*)&m_pDisp)) || !m_pDisp)
        return E_UNEXPECTED;

    gpCommMgr = this;
    m_pRefDial = new CRefDial();
    m_pWebGate = new CWebGate();

    //Ok, everything looks OK, try to setup a connection point.
    // Setup to get WebBrowserEvents
    return ConnectToConnectionPoint(pUnk,
                                    DIID_DObCommunicationEvents,
                                    TRUE,
                                    (IObCommunicationManager*)this,
                                    &m_dwcpCookie,
                                    NULL);
}

HRESULT CObCommunicationManager::ConnectToConnectionPoint(  IUnknown*          punkThis,
                                                            REFIID             riidEvent,
                                                            BOOL               fConnect,
                                                            IUnknown*          punkTarget,
                                                            DWORD*             pdwCookie,
                                                            IConnectionPoint** ppcpOut)
{
    HRESULT hr = E_FAIL;
    IConnectionPointContainer* pcpContainer = NULL;

    // We always need punkTarget, we only need punkThis on connect
    if (!punkTarget || (fConnect && !punkThis))
    {
        return E_FAIL;
    }

    if (ppcpOut)
        *ppcpOut = NULL;


    IConnectionPoint *pcp;
    if(SUCCEEDED(hr = FindConnectionPoint(riidEvent, &pcp)))
    {
        if(fConnect)
        {
            // Add us to the list of people interested...
            hr = pcp->Advise(punkThis, pdwCookie);
            if (FAILED(hr))
                *pdwCookie = 0;
        }
        else
        {
            // Remove us from the list of people interested...
            hr = pcp->Unadvise(*pdwCookie);
            *pdwCookie = 0;
        }

        if (ppcpOut && SUCCEEDED(hr))
            *ppcpOut = pcp;
        else
            pcp->Release();
            pcp = NULL;
    }

    return hr;
}


///////////////////////////////////////////////////////////
//
//                      IConnectionPointContainer
//
///////////////////////////////////////////////////////////
//
// EnumConnectionPoints
//
HRESULT CObCommunicationManager::EnumConnectionPoints(IEnumConnectionPoints **ppEnum)
{
    // Construct the enumerator object.
    //IEnumConnectionPoints* pEnum = new CEnumConnectionPoints(m_pConnectionPoint) ;

    // The contructor AddRefs for us.
    //*ppEnum = pEnum ;
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// FindConnectionPoint
//
HRESULT CObCommunicationManager::FindConnectionPoint(REFIID riid, IConnectionPoint **ppCP)
{
    // Model only supports a single connection point.
    if (riid != DIID_DObCommunicationEvents)
    {
        *ppCP = NULL ;
        return  CONNECT_E_NOCONNECTION ;
    }

    if (m_pConnectionPoint == NULL)
    {
        return E_FAIL ;
    }

    // Get the interface point to the connection point object.
    IConnectionPoint* pIConnectionPoint = m_pConnectionPoint ;

    // AddRef the interface.
    pIConnectionPoint->AddRef() ;

    // Return the interface to the client.
    *ppCP = pIConnectionPoint ;

    return S_OK ;
}


///////////////////////////////////////////////////////////
//  DWebBrowserEvents2 / IDispatch implementation
///////////////////////////////////////////////////////////

STDMETHODIMP CObCommunicationManager::GetTypeInfoCount(UINT* pcInfo)
{
    return E_NOTIMPL;
}

STDMETHODIMP CObCommunicationManager::GetTypeInfo(UINT, LCID, ITypeInfo** )
{
    return E_NOTIMPL;
}

// COleSite::GetIDsOfNames
STDMETHODIMP CObCommunicationManager::GetIDsOfNames(
            /* [in] */ REFIID riid,
            /* [size_is][in] */ OLECHAR** rgszNames,
            /* [in] */ UINT cNames,
            /* [in] */ LCID lcid,
            /* [size_is][out] */ DISPID* rgDispId)
{
    return ResultFromScode(DISP_E_UNKNOWNNAME);
}

/////////////////////////////////////////////////////////////
// COleSite::Invoke
HRESULT CObCommunicationManager::Invoke
(
    DISPID dispidMember,
    REFIID riid,
    LCID lcid,
    WORD wFlags,
    DISPPARAMS FAR* pdispparams,
    VARIANT FAR* pvarResult,
    EXCEPINFO FAR* pexcepinfo,
    UINT FAR* puArgErr
)
{
    HRESULT hr = DISP_E_MEMBERNOTFOUND;
   /*
    switch(dispidMember)
    {
        default:
           break;
    }
    */
    return hr;
}

/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////
//////  Methods
//////
//////
//////

///////////////////////////////////////////////////////////
//
//                      IMsobComm Interface
//
///////////////////////////////////////////////////////////
//
//  CheckDialReady
//
HRESULT CObCommunicationManager::CheckDialReady(DWORD *pdwRetVal)
{
    HINSTANCE hinst = NULL;
    FARPROC fp;
    HRESULT hr = E_FAIL;

    if (NULL == pdwRetVal)
        return ERR_COMM_UNKNOWN;

    *pdwRetVal = ERR_COMM_OOBE_COMP_MISSING;

    if (IsNT())
    {
        hinst = LoadLibrary(L"ICFGNT5.DLL");
    }
    else
    {
        hinst = LoadLibrary(L"ICFG95.DLL");
    }


    if (hinst)
    {
        fp = GetProcAddress(hinst, "IcfgNeedInetComponents");
        if (fp)
        {

            DWORD dwfInstallOptions = ICFG_INSTALLTCP;
            dwfInstallOptions |= ICFG_INSTALLRAS;
            dwfInstallOptions |= ICFG_INSTALLDIALUP;
            //dwfInstallOptions |= ICFG_INSTALLMAIL;
            BOOL  fNeedSysComponents = FALSE;

            DWORD dwRet = ((ICFGNEEDSYSCOMPONENTS)fp)(dwfInstallOptions, &fNeedSysComponents);

            if (ERROR_SUCCESS == dwRet)
            {
                // We don't have RAS or TCPIP
                if (fNeedSysComponents)
                {
                    *pdwRetVal = ERR_COMM_RAS_TCP_NOTINSTALL;
                    TRACE(L"RAS or TCPIP not install");
                }
                else
                {
                    // check modem
                    // The does does not exist, we failed.
                    m_EnumModem.ReInit();
                    if (NULL != m_EnumModem.GetDeviceNameFromType(RASDT_Modem))
                    {
                        if (NULL == m_EnumModem.GetDeviceNameFromType(RASDT_Isdn))
                        {
                            *pdwRetVal = ERR_COMM_NO_ERROR;
                        }
                        else
                        {
                            *pdwRetVal = ERR_COMM_PHONE_AND_ISDN;
                        }
                    }
                    else if (NULL != m_EnumModem.GetDeviceNameFromType(RASDT_Isdn))
                    {
                        *pdwRetVal = ERR_COMM_ISDN;
                    }
                    else
                    {
                        *pdwRetVal = ERR_COMM_NOMODEM;
                    }
                }

            }
            hr = S_OK;
        }
        FreeLibrary(hinst);
    }

    return hr ;
}


//////////////////////////////////////////////////////////////////////////////
//
//  GetConnectionCapabilities
//
//  Retrieves LAN connection capabilities.
//
//  For Whistler we rely on the modem path through EnumModem and RAS to
//  determine whether a modem is installed.
//
//
//  parameters:
//      _parm_          _description_
//
//  returns:
//      _description_
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::GetConnectionCapabilities(
    DWORD*              pdwConnectionCapabilities
    )
{
    TRACE(L"CObCommunicationManager::GetConnectionCapabilities\n");
    return m_ConnectionManager.GetCapabilities(pdwConnectionCapabilities);

}   //  CObCommunicationManager::GetConnectionCapabilities


//////////////////////////////////////////////////////////////////////////////
//
//  GetPreferredConnection
//
//  _abstract_
//
//  parameters:
//      _parm_          _description_
//
//  returns:
//      _description_
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::GetPreferredConnection(
    DWORD*              pdwPreferredConnection
    )
{
    return m_ConnectionManager.GetPreferredConnection(pdwPreferredConnection);

}   //  CObCommunicationManager::GetPreferredConnection


//////////////////////////////////////////////////////////////////////////////
//
//  SetPreferredConnection
//
//  _abstract_
//
//  parameters:
//      _parm_          _description_
//
//  returns:
//      _description_
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::SetPreferredConnection(
    const DWORD         dwPreferredConnection,
    BOOL*               pfSupportedType
    )
{
    return  m_ConnectionManager.SetPreferredConnection(dwPreferredConnection,
                                                       pfSupportedType
                                                       );

}   //  CObCommunicationManager::SetPreferredConnection

//////////////////////////////////////////////////////////////////////////////
//
//  ConnectedToInternet
//
//  _abstract_
//
//  parameters:
//      _parm_          _description_
//
//  returns:
//      _description_
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::ConnectedToInternet(
    BOOL*               pfConnected
    )
{
    return  m_ConnectionManager.ConnectedToInternet(pfConnected); 

}   //  CObCommunicationManager::ConnectedToInternet

//////////////////////////////////////////////////////////////////////////////
//
//  ConnectedToInternetEx
//
//  _abstract_
//
//  parameters:
//      _parm_          _description_
//
//  returns:
//      _description_
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::ConnectedToInternetEx(
    BOOL*               pfConnected
    )
{
    return  m_ConnectionManager.ConnectedToInternetEx(pfConnected); 

}   //  CObCommunicationManager::ConnectedToInternetEx

//////////////////////////////////////////////////////////////////////////////
//
//  AsyncConnectedToInternetEx
//
//  _abstract_
//
//  parameters:
//      _parm_          _description_
//
//  returns:
//      _description_
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::AsyncConnectedToInternetEx(
    const HWND          hwnd
    )
{
    return  m_ConnectionManager.AsyncConnectedToInternetEx(hwnd); 

}   //  CObCommunicationManager::AsyncConnectedToInternetEx

///////////////////////////////////////////////////////////
//
// SetPreferredConnectionTcpipProperties
//
STDMETHODIMP CObCommunicationManager::SetPreferredConnectionTcpipProperties(
    BOOL fAutoIPAddress,
    DWORD StaticIp_A,
    DWORD StaticIp_B,
    DWORD StaticIp_C,
    DWORD StaticIp_D,
    DWORD SubnetMask_A,
    DWORD SubnetMask_B,
    DWORD SubnetMask_C,
    DWORD SubnetMask_D,
    DWORD DefGateway_A,
    DWORD DefGateway_B,
    DWORD DefGateway_C,
    DWORD DefGateway_D,
    BOOL fAutoDNS,
    DWORD DnsPref_A,
    DWORD DnsPref_B,
    DWORD DnsPref_C,
    DWORD DnsPref_D,
    DWORD DnsAlt_A,
    DWORD DnsAlt_B,
    DWORD DnsAlt_C,
    DWORD DnsAlt_D,
    BOOL fFirewallRequired
    )
{
    HRESULT             hr;
    hr = m_ConnectionManager.SetPreferredConnectionTcpipProperties(
                                                            fAutoIPAddress, 
                                                            StaticIp_A, 
                                                            StaticIp_B, 
                                                            StaticIp_C, 
                                                            StaticIp_D, 
                                                            SubnetMask_A,
                                                            SubnetMask_B,
                                                            SubnetMask_C,
                                                            SubnetMask_D,
                                                            DefGateway_A,
                                                            DefGateway_B,
                                                            DefGateway_C,
                                                            DefGateway_D,
                                                            fAutoDNS, 
                                                            DnsPref_A, 
                                                            DnsPref_B, 
                                                            DnsPref_C, 
                                                            DnsPref_D, 
                                                            DnsAlt_A, 
                                                            DnsAlt_B, 
                                                            DnsAlt_C, 
                                                            DnsAlt_D
                                                            );    
    if (SUCCEEDED(hr) && fFirewallRequired)
    {
       // Save the connectoid name so it can be firewalled by the HomeNet
       // Wizard.
       m_ConnectionManager.GetPreferredConnectionName(
                                m_szExternalConnectoid,
                                sizeof(m_szExternalConnectoid)/sizeof(WCHAR)
                                ); 
    }

    return hr;
                                                            
}   //  CObCommunicationManager::SetPreferredConnectionTcpipProperties

///////////////////////////////////////////////////////////
//
// FirewallPreferredConnection
//
HRESULT CObCommunicationManager::FirewallPreferredConnection(BOOL bFirewall)
{
    m_bFirewall = bFirewall;   
    if (bFirewall)
    {
        // Save the connectoid name so it can be firewalled by the HomeNet
        // Wizard.
        return m_ConnectionManager.GetPreferredConnectionName(
                                m_szExternalConnectoid,
                                sizeof(m_szExternalConnectoid)/sizeof(WCHAR)
                                );
    }
    else
    {
        m_szExternalConnectoid[0] = TEXT('\0');
        return S_OK;
    }
    
}   //  CObCommunicationManager::FirewallPreferredConnection

///////////////////////////////////////////////////////////
//
//  SetupForDialing
//
HRESULT CObCommunicationManager::SetupForDialing(UINT nType, BSTR bstrISPFile, DWORD dwCountry, BSTR bstrAreaCode, DWORD dwFlag, DWORD dwAppMode, DWORD dwMigISPIdx)
{
    HRESULT hr = E_FAIL;
    
    if (m_pRefDial)
    {
        BSTR bstrDeviceName = GetPreferredModem();

        if (bstrDeviceName)
        {
            hr = m_pRefDial->SetupForDialing(
                nType,
                bstrISPFile,
                dwCountry,
                bstrAreaCode,
                dwFlag,
                dwAppMode,
                dwMigISPIdx,
                bstrDeviceName);
            
            SysFreeString(bstrDeviceName);
        }
    }
    return hr;
}

///////////////////////////////////////////////////////////
//
//  DoConnect
//
HRESULT CObCommunicationManager::DoConnect(BOOL *pbRetVal)
{

    if (m_pRefDial)
    {
        return m_pRefDial->DoConnect(pbRetVal);
    }

    return E_FAIL ;
}


///////////////////////////////////////////////////////////
//
//  SetRASCallbackHwnd
//
HRESULT CObCommunicationManager::SetRASCallbackHwnd(HWND hwndCallback)
{
    m_hwndCallBack = hwndCallback;

    return S_OK;
}

///////////////////////////////////////////////////////////
//
// DoHangup
//
HRESULT CObCommunicationManager::DoHangup()
{
    if (m_pRefDial)
    {
        m_pRefDial->m_bUserInitiateHangup = TRUE;
        m_pRefDial->DoHangup();
    }

    return S_OK ;
}


///////////////////////////////////////////////////////////
//
// GetDialPhoneNumber
//
HRESULT CObCommunicationManager::GetDialPhoneNumber(BSTR *pVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->GetDialPhoneNumber(pVal);
    }

    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// GetPhoneBookNumber
//
HRESULT CObCommunicationManager::GetPhoneBookNumber(BSTR *pVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->GetPhoneBookNumber(pVal);
    }

    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// PutDialPhoneNumber
//
HRESULT CObCommunicationManager::PutDialPhoneNumber(BSTR newVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->PutDialPhoneNumber(newVal);
    }

    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// SetDialAlternative
//
HRESULT CObCommunicationManager::SetDialAlternative(BOOL bVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->SetDialAlternative(bVal);
    }

    return S_OK;
}
///////////////////////////////////////////////////////////
//
// GetDialErrorMsg
//
HRESULT CObCommunicationManager::GetDialErrorMsg(BSTR *pVal)
{
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// GetSupportNumber
//
HRESULT CObCommunicationManager::GetSupportNumber(BSTR *pVal)
{
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// RemoveConnectoid
//
HRESULT CObCommunicationManager::RemoveConnectoid(BOOL *pbRetVal)
{
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// GetSignupURL
//
HRESULT CObCommunicationManager::GetSignupURL(BSTR *pVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->get_SignupURL(pVal);
    }
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// GetReconnectURL
//
HRESULT CObCommunicationManager::GetReconnectURL(BSTR *pVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->get_ReconnectURL(pVal);
    }
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// GetConnectionType
//
HRESULT CObCommunicationManager::GetConnectionType(DWORD *pdwVal)
{
    if (m_pRefDial)
    {
        m_pRefDial->GetConnectionType(pdwVal);
    }
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// FetchPage
//
HRESULT CObCommunicationManager::FetchPage(BSTR bstrURL, BSTR* pbstrLocalFile)
{
    BOOL bRetVal = 0;
    if (m_pWebGate && pbstrLocalFile)
    {
        BSTR bstrFileName = NULL;
        m_pWebGate->put_Path(bstrURL);
        m_pWebGate->FetchPage(1, &bRetVal);
        m_pWebGate->get_DownloadFname(&bstrFileName);
        *pbstrLocalFile = SysAllocString(bstrFileName);
        TRACE2(L"CObCommunicationManager::FetchPage(%s, %s)\n",
               bstrURL ? bstrURL : NULL, 
               bstrFileName ? bstrFileName : NULL
               );
    }
    if (bRetVal)
        return S_OK ;
    return E_FAIL;
}

///////////////////////////////////////////////////////////
//
// GetFile
//
HRESULT CObCommunicationManager::GetFile(BSTR bstrURL, BSTR bstrFileFullName)
{
    if (m_pWebGate && bstrURL)
    {
        // Check for HTTP prefix
        if (PathIsURL(bstrURL))
        {

            BOOL bRetVal = FALSE;
            m_pWebGate->put_Path(bstrURL);
            m_pWebGate->FetchPage(1, &bRetVal);
            if (bRetVal && bstrFileFullName)
            {
                BSTR bstrTempFile = NULL;
                m_pWebGate->get_DownloadFname(&bstrTempFile);
                // Make sure we have a valid file name
                if (bstrTempFile)
                {
                    if (CopyFile(bstrTempFile, bstrFileFullName, FALSE))
                    {
                        // Delete the temp file
                        DeleteFile(bstrTempFile);
                        return S_OK;
                    }
                }
            }
        }

    }
    return E_FAIL ;
}

///////////////////////////////////////////////////////////
//
//  CheckPhoneBook
//
HRESULT CObCommunicationManager::CheckPhoneBook(BSTR bstrISPFile, DWORD dwCountry, BSTR bstrAreaCode, DWORD dwFlag, BOOL *pbRetVal)
{
    if (m_pRefDial)
    {
        return m_pRefDial->CheckPhoneBook(bstrISPFile, dwCountry, bstrAreaCode, dwFlag, pbRetVal);
    }
    return E_FAIL ;
}

///////////////////////////////////////////////////////////
//
//  RestoreConnectoidInfo
//
HRESULT CObCommunicationManager::RestoreConnectoidInfo()
{
    if (!m_InsHandler)
        m_InsHandler = new CINSHandler;

    if (m_InsHandler)
    {
        return m_InsHandler->RestoreConnectoidInfo();
    }
    return E_FAIL ;
}

///////////////////////////////////////////////////////////
//
//  SetPreloginMode
//
HRESULT CObCommunicationManager::SetPreloginMode(BOOL bVal)
{
    m_pbPreLogin = bVal;
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// DownloadFileBuffer
//
HRESULT CObCommunicationManager::DownloadFileBuffer(BSTR *pVal)
{
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// ProcessINS
//
HRESULT CObCommunicationManager::ProcessINS(BSTR bstrINSFilePath, BOOL *pbRetVal)
{

    HRESULT hr = E_FAIL;
    if (!m_InsHandler)
    {
        m_InsHandler = new CINSHandler;
        if (m_InsHandler == NULL)
        {
            return hr;
        }
    }

    if (NULL == bstrINSFilePath)
    {
        *pbRetVal = m_InsHandler->ProcessOEMBrandINS(NULL,
                                                     m_szExternalConnectoid
                                                     );
        hr = S_OK;

    }
    else
    {
        // Download the ins file, then merge it with oembrnd.ins
        // Check for HTTP prefix
        if (PathIsURL(bstrINSFilePath))
        {
            if (m_pWebGate)
            {
                BOOL bRetVal;
                m_pWebGate->put_Path(bstrINSFilePath);
                m_pWebGate->FetchPage(1, &bRetVal);
                if (bRetVal)
                {
                    BSTR bstrINSTempFile = NULL;
                    if (S_OK == m_pWebGate->get_DownloadFname(&bstrINSTempFile))
                    {
                        if (bstrINSTempFile)
                        {
                            *pbRetVal = m_InsHandler->ProcessOEMBrandINS(
                                                    bstrINSTempFile,
                                                    m_szExternalConnectoid
                                                    );
                            hr = S_OK;
                        }
                        DeleteFile(bstrINSTempFile);
                    }
                }
            }
        }
        else
        {
            *pbRetVal = m_InsHandler->ProcessOEMBrandINS(
                                                    bstrINSFilePath,
                                                    m_szExternalConnectoid
                                                    );
            hr = S_OK;
        }
    }
    HKEY  hKey;
    if ((S_OK == hr) && *pbRetVal)
    {
        if((ERROR_SUCCESS == RegOpenKeyEx(HKEY_LOCAL_MACHINE,
                                          REG_KEY_OOBE_TEMP,
                                          0,
                                          KEY_WRITE,
                                          &hKey)) && hKey)
        {

            hr = RegSetValueEx(hKey,
                          REG_VAL_ISPSIGNUP,
                          0,
                          REG_DWORD,
                          (BYTE*)pbRetVal,
                          sizeof(*pbRetVal));
            RegCloseKey(hKey);
        }
        else
        {
            DWORD dwDisposition  = 0;
            if ( ERROR_SUCCESS == RegCreateKeyEx( HKEY_LOCAL_MACHINE,
                                                   REG_KEY_OOBE_TEMP,
                                                   0,
                                                   NULL,
                                                   REG_OPTION_NON_VOLATILE,
                                                   KEY_ALL_ACCESS,
                                                   NULL,
                                                   &hKey,
                                                   &dwDisposition))
            {
                hr = RegSetValueEx(hKey,
                              REG_VAL_ISPSIGNUP,
                              0,
                              REG_DWORD,
                              (BYTE*)pbRetVal,
                              sizeof(*pbRetVal));
                RegCloseKey(hKey);
            }
        }
    }
    return hr ;
}

///////////////////////////////////////////////////////////
//
// CheckKbdMouse
//
HRESULT CObCommunicationManager::CheckKbdMouse(DWORD *pdwRetVal)
{
    BOOL bkeyboard, bmouse;

    *pdwRetVal = 0;

    // summary: *pdwRetVal returns
    // 0 = Success (keyboard and mouse present
    // 1 = Keyboard is missing
    // 2 = Mouse is missing
    // 3 = Keyboard and mouse are missing

    IsMouseOrKeyboardPresent(m_hwndCallBack,
                         &bkeyboard,
                         &bmouse);
    // If there is a keyboard, set the first bit to 1
    if (bkeyboard)
        *pdwRetVal |= 0x01;

    // If there is a mouse, set the first bit to 1
    if (bmouse)
        *pdwRetVal |= 0x02;

    return S_OK;
}

///////////////////////////////////////////////////////////
//
// Fire_Dialing
//
HRESULT CObCommunicationManager::Fire_Dialing(DWORD dwDialStatus)
{
    VARIANTARG varg;
    VariantInit(&varg);
    varg.vt  = VT_I4;
    varg.lVal= dwDialStatus;
    DISPPARAMS disp = { &varg, NULL, 1, 0 };
    m_pDisp->Invoke(DISPID_DIALING, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// Fire_Connecting
//
HRESULT CObCommunicationManager::Fire_Connecting()
{
    VARIANTARG varg;
    VariantInit(&varg);
    varg.vt  = VT_I4;
    varg.lVal= 0;
    DISPPARAMS disp = { &varg, NULL, 1, 0 };
    m_pDisp->Invoke(DISPID_CONNECTING, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// Fire_DialError
//
HRESULT CObCommunicationManager::Fire_DialError(DWORD dwErrorCode)
{
    VARIANTARG varg;
    VariantInit(&varg);
    varg.vt  = VT_I4;
    varg.lVal= dwErrorCode;
    DISPPARAMS disp = { &varg, NULL, 1, 0 };
    m_pDisp->Invoke(DISPID_DIALINGERROR, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// Fire_ConnectionComplete
//
HRESULT CObCommunicationManager::Fire_ConnectionComplete()
{
    VARIANTARG varg;
    VariantInit(&varg);
    varg.vt  = VT_I4;
    varg.lVal= 0;
    DISPPARAMS disp = { &varg, NULL, 1, 0 };
    m_pDisp->Invoke(DISPIP_CONNECTIONCOMPLETE, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// Fire_DownloadComplete
//
HRESULT CObCommunicationManager::Fire_DownloadComplete(BSTR pVal)
{
    VARIANTARG varg;
    VariantInit(&varg);
    varg.vt = VT_BSTR;
    varg.bstrVal= pVal;
    DISPPARAMS disp = { &varg, NULL, 1, 0 };
    m_pDisp->Invoke(DISPIP_DOWNLOADCOMPLETE, IID_NULL, LOCALE_USER_DEFAULT, DISPATCH_METHOD, &disp, NULL, NULL, NULL);
    return S_OK ;
}

///////////////////////////////////////////////////////////
//
// OnDownloadEvent
//
HRESULT CObCommunicationManager::OnDownloadEvent(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL* bHandled)
{
    return m_pRefDial->OnDownloadEvent(uMsg, wParam, lParam, bHandled);
}

///////////////////////////////////////////////////////////
//
// GetISPList
//
HRESULT CObCommunicationManager::GetISPList(BSTR* pVal)
{
    return m_pRefDial->GetISPList(pVal);
}

///////////////////////////////////////////////////////////
//
// GetISPList
//
HRESULT CObCommunicationManager::Set_SelectISP(UINT nVal)
{
    return m_pRefDial->Set_SelectISP(nVal);
}

///////////////////////////////////////////////////////////
//
// Set_ConnectionMode
//
HRESULT CObCommunicationManager::Set_ConnectionMode(UINT nVal)
{
    return m_pRefDial->Set_ConnectionMode(nVal);
}

///////////////////////////////////////////////////////////
//
// Get_ConnectionMode
//
HRESULT CObCommunicationManager::Get_ConnectionMode(UINT* pnVal)
{
    return m_pRefDial->Get_ConnectionMode(pnVal);
}


///////////////////////////////////////////////////////////
//
// DownloadReferralOffer
//
HRESULT CObCommunicationManager::DownloadReferralOffer(BOOL *pbVal)
{
    if (pbVal)
    {
        // Start the download now!!!
        m_pRefDial->DoOfferDownload(pbVal);
        if (!*pbVal)
            m_pRefDial->DoHangup();
        return S_OK;
    }
    return E_FAIL;

}

///////////////////////////////////////////////////////////
//
// DownloadISPOffer
//
HRESULT CObCommunicationManager::DownloadISPOffer(BOOL *pbVal, BSTR *pVal)
{
    if (pbVal && pVal)
    {
        // Start the download now!!!
        m_pRefDial->DownloadISPOffer(pbVal, pVal);
        if (!*pbVal)
            m_pRefDial->DoHangup();
        return S_OK;
    }
    return E_FAIL;
}

///////////////////////////////////////////////////////////
//
// Get_ISPName
//
HRESULT CObCommunicationManager::Get_ISPName(BSTR *pVal)
{
    if (pVal)
    {
        // Start the download now!!!
        return m_pRefDial->get_ISPName(pVal);
    }
    return E_FAIL;
}


///////////////////////////////////////////////////////////
//
// RemoveDownloadDir
//
HRESULT CObCommunicationManager::RemoveDownloadDir()
{
    return m_pRefDial->RemoveDownloadDir();
}

///////////////////////////////////////////////////////////
//
// PostRegData
//
HRESULT CObCommunicationManager::PostRegData(DWORD dwSrvType, BSTR bstrRegUrl)
{
    return m_pRefDial->PostRegData(dwSrvType, bstrRegUrl);
}

///////////////////////////////////////////////////////////
//
// AllowSingleCall
//
HRESULT CObCommunicationManager::CheckStayConnected(BSTR bstrISPFile, BOOL *pbVal)
{
    return m_pRefDial->CheckStayConnected(bstrISPFile, pbVal);
}

///////////////////////////////////////////////////////////
//
//  Connect
//
HRESULT CObCommunicationManager::Connect(UINT nType, BSTR bstrISPFile, DWORD dwCountry, BSTR bstrAreaCode, DWORD dwFlag, DWORD dwAppMode)
{
    if (m_pRefDial)
    {
        return m_pRefDial->Connect(nType, bstrISPFile, dwCountry, bstrAreaCode, dwFlag, dwAppMode);
    }
    return E_FAIL ;
}


///////////////////////////////////////////////////////////
//
// CheckStayConnected
//
HRESULT CObCommunicationManager::CheckOnlineStatus(BOOL *pbVal)
{
    if (pbVal)
    {
        BOOL    bIcs = FALSE;
        BOOL    bModem = FALSE;
        IsIcsAvailable (&bIcs); // we don't care about the return value here
        m_pRefDial->CheckOnlineStatus(&bModem);
        *pbVal = (bIcs || bModem); // we are online if we have ICS  or if the modem is connected.
        return S_OK;
    }
    return E_FAIL;

}
HRESULT CObCommunicationManager::CreateIcsBot(DWORD *pdwRetVal)
{
    if (!m_IcsMgr) {
        if (!(m_IcsMgr  = new CIcsMgr())) {
            return ERROR_NOT_ENOUGH_MEMORY;
        }
    }
    if (!pdwRetVal) {
        return ERROR_INVALID_PARAMETER;
    }
    *pdwRetVal = m_IcsMgr->CreateIcsDialMgr();
    return ERROR_SUCCESS;
}
HRESULT CObCommunicationManager::IsIcsAvailable(BOOL *bRetVal)
{
    if (!bRetVal) {
        return ERROR_INVALID_PARAMETER;
    }
    if (!m_IcsMgr) {
        *bRetVal = FALSE;

    } else {
        *bRetVal = m_IcsMgr->IsIcsAvailable();
    }
    return S_OK;
}

HRESULT CObCommunicationManager::IsCallbackUsed(BOOL *bRetVal)
{
    if (!bRetVal) {
        return E_FAIL;
    }
    if (!m_IcsMgr) {
        *bRetVal = FALSE;

    } else {
        *bRetVal = m_IcsMgr->IsCallbackUsed();
    }
    return S_OK;
}

HRESULT CObCommunicationManager::NotifyIcsMgr(UINT msg, WPARAM wParam, LPARAM lParam)
{
    if ( !m_IcsMgr )
        return E_FAIL;
    else
        m_IcsMgr->NotifyIcsMgr(msg, wParam, lParam);
    return S_OK;
}

HRESULT CObCommunicationManager::NotifyIcsUsage(BOOL bParam)
{
    m_bIsIcsUsed = bParam;
    return S_OK;
}

HRESULT CObCommunicationManager::TriggerIcsCallback(BOOL bParam)
{
    if (!m_IcsMgr)
    {
        return E_FAIL;
    }
    else
    {
        // The Dial Manager is initialized only once, even if
        // TriggerIcsCallback is called several times.
        // m_IcsMgr->CreateIcsDialMgr();
        m_IcsMgr->TriggerIcsCallback(bParam);
        return S_OK;
    }
}

HRESULT CObCommunicationManager::IsIcsHostReachable(BOOL *bRetVal)
{
    if (!bRetVal) {
        return E_FAIL;
    }
    if (!m_IcsMgr) {
        *bRetVal = FALSE;

    } else {
        *bRetVal = m_IcsMgr->IsIcsHostReachable();
    }
    return S_OK;
}

///////////////////////////////////////////////////////////
//
// CreateModemConnectoid
//
STDMETHODIMP CObCommunicationManager::CreateModemConnectoid(
    BSTR bstrPhoneBook,
    BSTR bstrConnectionName,
    DWORD dwCountryID,
    DWORD dwCountryCode,
    BSTR bstrAreaCode,
    BSTR bstrPhoneNumber,
    BOOL fAutoIPAddress,
    DWORD ipaddr_A,
    DWORD ipaddr_B,
    DWORD ipaddr_C,
    DWORD ipaddr_D,
    BOOL fAutoDNS,
    DWORD ipaddrDns_A,
    DWORD ipaddrDns_B,
    DWORD ipaddrDns_C,
    DWORD ipaddrDns_D,
    DWORD ipaddrDnsAlt_A,
    DWORD ipaddrDnsAlt_B,
    DWORD ipaddrDnsAlt_C,
    DWORD ipaddrDnsAlt_D,
    BSTR bstrUserName,
    BSTR bstrPassword)
{
    DWORD dwRet = ERROR_SUCCESS;

    dwRet = m_EnumModem.ReInit();
    if (ERROR_SUCCESS != dwRet)
    {
        return dwRet;
    }

    LPWSTR szDeviceName = m_EnumModem.GetDeviceNameFromType(RASDT_Modem);
    if (NULL == szDeviceName)
    {
        return ERROR_DEVICE_DOES_NOT_EXIST;
    }

    BSTR bstrDeviceName = SysAllocString(szDeviceName);
    BSTR bstrDeviceType = SysAllocString(RASDT_Modem);
    if (NULL == bstrDeviceName || NULL == bstrDeviceType)
    {
        dwRet = ERROR_NOT_ENOUGH_MEMORY;
    }
    else 
    {

        DWORD dwEntryOptions = RASEO_UseCountryAndAreaCodes
                             | RASEO_IpHeaderCompression
                             | RASEO_RemoteDefaultGateway
                             | RASEO_SwCompression
                             | RASEO_ShowDialingProgress
                             | RASEO_ModemLights;

        dwRet = CreateConnectoid(bstrPhoneBook,
                                bstrConnectionName,
                                dwCountryID,
                                dwCountryCode,
                                bstrAreaCode,
                                bstrPhoneNumber,
                                fAutoIPAddress,
                                ipaddr_A,
                                ipaddr_B,
                                ipaddr_C,
                                ipaddr_D,
                                fAutoDNS,
                                ipaddrDns_A,
                                ipaddrDns_B,
                                ipaddrDns_C,
                                ipaddrDns_D,
                                ipaddrDnsAlt_A,
                                ipaddrDnsAlt_B,
                                ipaddrDnsAlt_C,
                                ipaddrDnsAlt_D,
                                bstrUserName,
                                bstrPassword,
                                bstrDeviceName,
                                bstrDeviceType,
                                dwEntryOptions,
                                RASET_Phone
                                );
    }
    
    if (bstrDeviceName) SysFreeString(bstrDeviceName);
    if (bstrDeviceType) SysFreeString(bstrDeviceType);

    // BUGBUG: Mixing HRESULT and WIN32 error code
    return dwRet;

}

///////////////////////////////////////////////////////////
//
// CreatePppoeConnectoid
//
STDMETHODIMP CObCommunicationManager::CreatePppoeConnectoid(
    BSTR bstrPhoneBook,
    BSTR bstrConnectionName,
    BSTR bstrBroadbandService,
    BOOL fAutoIPAddress,
    DWORD ipaddr_A,
    DWORD ipaddr_B,
    DWORD ipaddr_C,
    DWORD ipaddr_D,
    BOOL fAutoDNS,
    DWORD ipaddrDns_A,
    DWORD ipaddrDns_B,
    DWORD ipaddrDns_C,
    DWORD ipaddrDns_D,
    DWORD ipaddrDnsAlt_A,
    DWORD ipaddrDnsAlt_B,
    DWORD ipaddrDnsAlt_C,
    DWORD ipaddrDnsAlt_D,
    BSTR bstrUserName,
    BSTR bstrPassword)
{
    
    DWORD dwRet = ERROR_SUCCESS;

    dwRet = m_EnumModem.ReInit();
    if (ERROR_SUCCESS != dwRet)
    {
        return dwRet;
    }

    LPWSTR szDeviceName = m_EnumModem.GetDeviceNameFromType(RASDT_PPPoE);
    if (NULL == szDeviceName)
    {
        return ERROR_DEVICE_DOES_NOT_EXIST;
    }

    BSTR bstrDeviceName = SysAllocString(szDeviceName);
    BSTR bstrDeviceType = SysAllocString(RASDT_PPPoE);
    if (NULL == bstrDeviceName || NULL == bstrDeviceType)
    {
        dwRet = ERROR_NOT_ENOUGH_MEMORY;
    }
    else
    {
        DWORD dwEntryOptions = RASEO_IpHeaderCompression
                             | RASEO_RemoteDefaultGateway
                             | RASEO_SwCompression
                             | RASEO_ShowDialingProgress
                             | RASEO_ModemLights;
        
        // Note that bstrBroadbandService is passed as the bstrPhoneNumber param to
        // CreateConnectoid.  This is correct per PMay.  bstrBroadbandService may
        // contain the name of a broadband service or may be an empty string.
        //
        dwRet = CreateConnectoid(bstrPhoneBook,
                                bstrConnectionName,
                                0,                      // dwCountryID unused
                                0,                      // dwCountryCode unused
                                NULL,                   // area code
                                bstrBroadbandService,
                                fAutoIPAddress,
                                ipaddr_A,
                                ipaddr_B,
                                ipaddr_C,
                                ipaddr_D,
                                fAutoDNS,
                                ipaddrDns_A,
                                ipaddrDns_B,
                                ipaddrDns_C,
                                ipaddrDns_D,
                                ipaddrDnsAlt_A,
                                ipaddrDnsAlt_B,
                                ipaddrDnsAlt_C,
                                ipaddrDnsAlt_D,
                                bstrUserName,
                                bstrPassword,
                                bstrDeviceName,
                                bstrDeviceType,
                                dwEntryOptions,
                                RASET_Broadband
                                );
    }

    if (bstrDeviceName) SysFreeString(bstrDeviceName);
    if (bstrDeviceType) SysFreeString(bstrDeviceType);

    // BUGBUG: Mixing HRESULT and WIN32 error code
    return dwRet;

}

///////////////////////////////////////////////////////////
//
// CreateConnectoid
//
STDMETHODIMP CObCommunicationManager::CreateConnectoid(
    BSTR bstrPhoneBook,
    BSTR bstrConnectionName,
    DWORD dwCountryID,
    DWORD dwCountryCode,
    BSTR bstrAreaCode,
    BSTR bstrPhoneNumber,
    BOOL fAutoIPAddress,
    DWORD ipaddr_A,
    DWORD ipaddr_B,
    DWORD ipaddr_C,
    DWORD ipaddr_D,
    BOOL fAutoDNS,
    DWORD ipaddrDns_A,
    DWORD ipaddrDns_B,
    DWORD ipaddrDns_C,
    DWORD ipaddrDns_D,
    DWORD ipaddrDnsAlt_A,
    DWORD ipaddrDnsAlt_B,
    DWORD ipaddrDnsAlt_C,
    DWORD ipaddrDnsAlt_D,
    BSTR bstrUserName,
    BSTR bstrPassword,
    BSTR bstrDeviceName,
    BSTR bstrDeviceType,
    DWORD dwEntryOptions,
    DWORD dwEntryType)
{
    RNAAPI rnaapi;
    HRESULT hr;
    RASENTRY rasentry;
    WCHAR wsz[MAX_ISP_NAME + 1];

    // Set up the RASENTRY
    memset(&rasentry, 0, sizeof(RASENTRY));
    rasentry.dwSize = sizeof(RASENTRY);
    rasentry.dwfOptions = dwEntryOptions;

    //
    // Location/phone number.
    //
    rasentry.dwCountryID = dwCountryID;
    rasentry.dwCountryCode = dwCountryCode;
    
    TRACE2(L"Connectoid %d %d", dwCountryID, dwCountryCode);
    
    // bstrAreaCode will be NULL when creating a PPPOE connectoid
    //
    if (NULL != bstrAreaCode)
    {
        lstrcpyn(rasentry.szAreaCode, bstrAreaCode, RAS_MaxAreaCode + 1);

        TRACE1(L"Connectoid AreaCode %s", rasentry.szAreaCode);
    }
    // bstrPhoneNumber should contain either a phone number or a broadband
    // service name.
    //
    MYASSERT(NULL != bstrPhoneNumber);
    if (NULL != bstrPhoneNumber)
    {
        lstrcpyn(rasentry.szLocalPhoneNumber, 
                 bstrPhoneNumber, 
                 RAS_MaxPhoneNumber + 1
                 );

        TRACE1(L"Connectoid LocalPhoneNumber %s", rasentry.szLocalPhoneNumber);
    }
    // dwAlternateOffset; No alternate numbers
    //
    // PPP/Ip
    //
    if (!fAutoIPAddress)
    {
        rasentry.dwfOptions |= RASEO_SpecificIpAddr;
        rasentry.ipaddr.a = (BYTE)ipaddr_A;
        rasentry.ipaddr.b = (BYTE)ipaddr_B;
        rasentry.ipaddr.c = (BYTE)ipaddr_C;
        rasentry.ipaddr.d = (BYTE)ipaddr_D;

        TRACE4(L"Connectoid ipaddr %d.%d.%d.%d",
            ipaddr_A, ipaddr_B, ipaddr_C, ipaddr_D);
    }
    if (!fAutoDNS)
    {
        rasentry.dwfOptions |= RASEO_SpecificNameServers;
        rasentry.ipaddrDns.a = (BYTE)ipaddrDns_A;
        rasentry.ipaddrDns.b = (BYTE)ipaddrDns_B;
        rasentry.ipaddrDns.c = (BYTE)ipaddrDns_C;
        rasentry.ipaddrDns.d = (BYTE)ipaddrDns_D;

        TRACE4(L"Connectoid ipaddrDns %d.%d.%d.%d",
            ipaddrDns_A, ipaddrDns_B, ipaddrDns_C, ipaddrDns_D);
        
        rasentry.ipaddrDnsAlt.a = (BYTE)ipaddrDnsAlt_A;
        rasentry.ipaddrDnsAlt.b = (BYTE)ipaddrDnsAlt_B;
        rasentry.ipaddrDnsAlt.c = (BYTE)ipaddrDnsAlt_C;
        rasentry.ipaddrDnsAlt.d = (BYTE)ipaddrDnsAlt_D;

        TRACE4(L"Connectoid ipaddrDnsAlt %d.%d.%d.%d",
            ipaddrDnsAlt_A, ipaddrDnsAlt_B, ipaddrDnsAlt_C, ipaddrDnsAlt_D);
        
    // RASIPADDR  ipaddrWins;
    // RASIPADDR  ipaddrWinsAlt;
    }
    //
    // Framing
    //
    // dwFrameSize; Ignored unless framing is RASFP_Slip
    rasentry.dwfNetProtocols = RASNP_Ip;
    rasentry.dwFramingProtocol = RASFP_Ppp;
    //
    // Scripting
    //
    // szScript[ MAX_PATH ];
    //
    // AutoDial - Use the default dialer
    //
    // szAutodialDll[ MAX_PATH ];
    // szAutodialFunc[ MAX_PATH ];
    //
    // Device
    //
    if (NULL != bstrDeviceType)
    {
        lstrcpyn(rasentry.szDeviceType, bstrDeviceType, RAS_MaxDeviceType + 1);

        TRACE1(L"Connectoid DeviceType %s", rasentry.szDeviceType);
    }

    if (NULL != bstrDeviceName)
    {
        lstrcpyn(rasentry.szDeviceName, bstrDeviceName, RAS_MaxDeviceName + 1);

        TRACE1(L"Connectoid DeviceName %s", rasentry.szDeviceName);
    }

    //
    // X.25 - not using an X.25 device
    //
    // szX25PadType[ RAS_MaxPadType + 1 ];
    // szX25Address[ RAS_MaxX25Address + 1 ];
    // szX25Facilities[ RAS_MaxFacilities + 1 ];
    // szX25UserData[ RAS_MaxUserData + 1 ];
    // dwChannels;
    //
    // Reserved
    //
    // dwReserved1;
    // dwReserved2;
    //
    // Multilink and BAP
    //
    // dwSubEntries;
    // dwDialMode;
    // dwDialExtraPercent;
    // dwDialExtraSampleSeconds;
    // dwHangUpExtraPercent;
    // dwHangUpExtraSampleSeconds;
    //
    // Idle time out
    //
    // dwIdleDisconnectSeconds;
    //
    rasentry.dwType = dwEntryType;
    // dwEncryptionType;     // type of encryption to use
    // dwCustomAuthKey;      // authentication key for EAP
    // guidId;               // guid that represents
                             // the phone-book entry
    // szCustomDialDll[MAX_PATH];    // DLL for custom dialing
    // dwVpnStrategy;         // specifies type of VPN protocol

    TRACE5(L"Connectoid %d %d %d %d %d",
        rasentry.dwSize, rasentry.dwfOptions, rasentry.dwfNetProtocols,
        rasentry.dwFramingProtocol, rasentry.dwType);
    
    // Now pass all parameters to RAS
    hr = RasSetEntryProperties(bstrPhoneBook,
                               bstrConnectionName,
                               &rasentry,
                               sizeof(RASENTRY),
                               NULL,
                               0
                               );

    
    if (ERROR_SUCCESS == hr)
    {
        HRESULT        hr2;
        RASCREDENTIALS rascred;
        
        ZeroMemory(&rascred, sizeof(rascred));
        
        rascred.dwSize = sizeof(rascred);
        rascred.dwMask = RASCM_UserName 
                       | RASCM_Password 
                       | RASCM_Domain
                       | RASCM_DefaultCreds;
        
        if (bstrUserName != NULL)
        {
            lstrcpyn(rascred.szUserName, bstrUserName,UNLEN);
        }
        else
        {
            lstrcpyn(rascred.szUserName, L"", UNLEN);
        }
        
        if (bstrPassword != NULL)
        {
            lstrcpyn(rascred.szPassword, bstrPassword,PWLEN);
        }
        else
        {
            lstrcpyn(rascred.szPassword, L"", PWLEN);
        }
        
        lstrcpyn(rascred.szDomain, L"",DNLEN);

        hr2 = RasSetCredentials(bstrPhoneBook,
                                bstrConnectionName,
                                &rascred,
                                FALSE);

        TRACE1(L"Connectoid SetCredentials 0x%08lx", hr2);

        SetDefaultConnectoid(AutodialTypeNoNet, bstrConnectionName);
                    
        // Save the connectoid name so it can be firewalled by the HomeNet
        // Wizard.
        //
        lstrcpy(m_szExternalConnectoid, bstrConnectionName);
    }
    
    TRACE1(L"CreateConnectoid %d\n", hr);
    
    return hr;
}



//////////////////////////////////////////////////////////////////////////////
//
//  DoFinalTasks
//
//  This method is called during OOBE's Finish code.  Complete any final tasks
//  (ie, run the HomeNet Wizard) here.
//
//  parameters:
//      pfRebootRequired    pointer to a buffer that receives a boolean
//                          indicating whether a reboot is required before
//                          something done here will take affect.
//
//  returns:
//      HRESULT returned by CHomeNet::ConfigureSilently
//
//////////////////////////////////////////////////////////////////////////////
STDMETHODIMP CObCommunicationManager::DoFinalTasks(
    BOOL*               pfRebootRequired
    )
{
    HRESULT             hr = S_OK;
    BOOL                fRebootRequired = FALSE;
    LPCWSTR             szConnectoidName = (0 < lstrlen(m_szExternalConnectoid) 
                                            ? m_szExternalConnectoid 
                                            : NULL);

    if (szConnectoidName)
    {
        // Run the HomeNet Wizard sans UI.  m_szExternalConnectoid is the name of
        // the connectoid that will be firewalled.
        //
        CHomeNet            HomeNet;
        HomeNet.Create();

        // Run the HomeNet Wizard sans UI.  m_szExternalConnectoid is the name of
        // the connectoid that will be firewalled.
        //
        hr = HomeNet.ConfigureSilently(szConnectoidName,
                                       &fRebootRequired);
        if (FAILED(hr))
        {
            TRACE2(L"Failed: IHomeNetWizard::ConfigureSilently(%s): (0x%08X)",
                   m_szExternalConnectoid, hr
                   );
            fRebootRequired = FALSE;
        }
        else
        {
            TRACE1(L"Connection %s Firewalled", szConnectoidName);
        }
    }
    else if (m_bFirewall)
    {
        PSTRINGLIST List = NULL;
        
        m_ConnectionManager.EnumPublicConnections(&List);

        if (List)
        {
            CHomeNet HomeNet;
            if (SUCCEEDED(HomeNet.Create()))
            {                
                for (PSTRINGLIST p = List; p; p = p->Next)
                {
                    BOOL bRet = FALSE;

                    hr = HomeNet.ConfigureSilently(p->String, &bRet);
                    if (SUCCEEDED(hr))
                    {
                        TRACE1(L"Connection %s Firewalled", p->String);
                        if (bRet)
                        {
                            fRebootRequired = TRUE;
                        }
                    }
                    else
                    {
                        TRACE2(
                            L"Failed: IHomeNetWizard::ConfigureSilently(%s): (0x%08X)",
                            p->String,
                            hr
                            );
                    }
                }
            }
            else
            {
                TRACE1(L"Failed: IHomeNetWizard CoCreateInstance: (0x%08lx)", hr);
            }
            
            DestroyList(List);
            
        }
    }

    if (NULL != pfRebootRequired)
    {
        *pfRebootRequired = fRebootRequired;
    }

    return hr;

}   //  CObCommunicationManager::DoFinalTasks


HRESULT CObCommunicationManager::OobeAutodial()
{
    if (InternetAutodial(INTERNET_AUTODIAL_FORCE_ONLINE, m_hwndCallBack))
        return S_OK;
    else
        return E_FAIL;
}

HRESULT CObCommunicationManager::OobeAutodialHangup()
{
    if (InternetAutodialHangup(0))
    {
        return S_OK;
    }
    else
    {
        return E_FAIL;
    }
}

HRESULT CObCommunicationManager::UseWinntProxySettings()
{
    m_ConnectionManager.UseWinntProxySettings();
    return S_OK;
}

HRESULT CObCommunicationManager::DisableWinntProxySettings()
{
    m_ConnectionManager.DisableWinntProxySettings();
    return S_OK;
}

HRESULT CObCommunicationManager::GetProxySettings(
    BOOL* pbUseAuto,
    BOOL* pbUseScript,
    BSTR* pszScriptUrl,
    BOOL* pbUseProxy,
    BSTR* pszProxy
    )
{
    return m_ConnectionManager.GetProxySettings(
        pbUseAuto,
        pbUseScript,
        pszScriptUrl,
        pbUseProxy,
        pszProxy
        );
}

HRESULT CObCommunicationManager::SetProxySettings(
    BOOL bUseAuto,
    BOOL bUseScript,
    BSTR szScriptUrl,
    BOOL bUseProxy,
    BSTR szProxy
    )
{
    return m_ConnectionManager.SetProxySettings(
        bUseAuto,
        bUseScript,
        szScriptUrl,
        bUseProxy,
        szProxy
        );
}

BSTR CObCommunicationManager::GetPreferredModem()
{
    BSTR bstrVal = NULL;
    
    // Assume CObCommunicationManager::CheckDialReady has been called
    //
    LPWSTR szDeviceName = m_EnumModem.GetDeviceNameFromType(RASDT_Isdn);
    if (szDeviceName == NULL)
    {
        szDeviceName = m_EnumModem.GetDeviceNameFromType(RASDT_Modem);
    }

    if (szDeviceName != NULL)
    {
        bstrVal = SysAllocString(szDeviceName);
    }

    return bstrVal;
}

HRESULT CObCommunicationManager::SetICWCompleted(
    BOOL bMultiUser
    )
{
    BOOL bRet;
    
    if (bMultiUser)
    {
        bRet = SetMultiUserAutodial(AutodialTypeNever, NULL, TRUE);
    }
    else
    {
        bRet = SetAutodial(HKEY_CURRENT_USER, AutodialTypeNever, NULL, TRUE);
    }

    return (bRet) ? S_OK : E_FAIL;
}

//////////////////////////////////////////////////////////////////////////////
//
//  GetPublicLanCount
//
//  Forward the work to CConnectionManager::GetPublicLanCount
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::GetPublicLanCount(
    int*                pcPublicLan
    )
{
    return  m_ConnectionManager.GetPublicLanCount(pcPublicLan);
}   //  CObCommunicationManager::GetPublicLanCount

//////////////////////////////////////////////////////////////////////////////
//
//  SetExclude1394
//
//  Forward the work to CConnectionManager::SetExclude1394
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::SetExclude1394(
    BOOL bExclude
    )
{
    m_ConnectionManager.SetExclude1394(bExclude);
    return S_OK;
}   // CObCommunicationManager::SetExclude1394