able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/oobe/msobcomm/msobcomm.cpp

2156 lines
57 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//*********************************************************************
//* 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;
m_bAutodialCleanup = 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;
OobeAutodialHangup();
}
///////////////////////////////////////////////////////////
//
// 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
//////////////////////////////////////////////////////////////////////////////
//
// OobeAutodial
//
// This method invokes IE's autodial as a modal dialog.
//
// If a connection is established, it will be disconnected when
// OobeAutodialHangup is called or in this class's destructor.
//
// Precondition:
// no internet connectivity is available.
//
// returns:
// S_OK - connection established
// S_FALSE - no error. Autodial cancelled and no connection established
// HRESULT error code - error occured.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT CObCommunicationManager::OobeAutodial()
{
HRESULT hr = S_OK;
BOOL bRet = FALSE;
if (!InternetAutodial(INTERNET_AUTODIAL_FORCE_ONLINE, m_hwndCallBack))
{
hr = HRESULT_FROM_WIN32(GetLastError());
goto cleanup;
}
hr = ConnectedToInternetEx(&bRet);
if (FAILED(hr))
{
goto cleanup;
}
if (bRet)
{
hr = S_OK;
m_bAutodialCleanup = true;
}
else
{
hr = S_FALSE;
}
cleanup:
return hr;
}
//////////////////////////////////////////////////////////////////////////////
//
// OobeAutodialHangup
//
// This method disconnects the autodial connection, if there is one, created
// by OobeAutodial
//
// returns:
// S_OK - no connection is created by OobeAutodial or hangup succeeded
// HRESULT error code - error occured.
//
//////////////////////////////////////////////////////////////////////////////
HRESULT CObCommunicationManager::OobeAutodialHangup()
{
HRESULT hr = S_OK;
if (m_bAutodialCleanup)
{
if (!InternetAutodialHangup(0))
{
hr = HRESULT_FROM_WIN32(GetLastError());
}
m_bAutodialCleanup = FALSE;
}
return hr;
}
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
//////////////////////////////////////////////////////////////////////////////
//
// GnsAutodial
//
// Forward the work to CRefDial::SetupForAutoDial
//
//////////////////////////////////////////////////////////////////////////////
HRESULT
CObCommunicationManager::GnsAutodial(
BOOL bEnabled,
BSTR bstrUserSection
)
{
HRESULT hr = S_OK;
if (m_pRefDial)
{
hr = m_pRefDial->SetupForAutoDial(bEnabled, bstrUserSection);
}
return hr;
} // CObCommunicationManager::GnsAutodial
Reference in a new issue Copy permalink