992 lines
28 KiB
C++
992 lines
28 KiB
C++
//+---------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
// Copyright (C) Microsoft Corporation, 1997.
|
|
//
|
|
// File: L A N U I O B J. C P P
|
|
//
|
|
// Contents: Implementation of the LAN ConnectionUI object
|
|
//
|
|
// Notes:
|
|
//
|
|
// Created: tongl 8 Oct 1997
|
|
//
|
|
//----------------------------------------------------------------------------
|
|
|
|
#include "pch.h"
|
|
#pragma hdrstop
|
|
#include "lancmn.h"
|
|
#include "lanui.h"
|
|
#include "wzcui.h"
|
|
#include "lanuiobj.h"
|
|
#include "lanwiz.h"
|
|
#include "ncnetcon.h"
|
|
#include "ncras.h"
|
|
#include "lanhelp.h"
|
|
#include "ncperms.h"
|
|
#include "advpage.h"
|
|
#include "cfpidl.h"
|
|
#include "..\folder\confold.h"
|
|
#include "..\folder\connlist.h"
|
|
#include "ncsvc.h"
|
|
|
|
extern const WCHAR c_szBiNdisAtm[];
|
|
extern const WCHAR c_szInfId_MS_AtmElan[];
|
|
const WCHAR c_szTcpip[] = L"Tcpip";
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// INetConnectionUI
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::SetConnection
|
|
//
|
|
// Purpose: Sets the LAN connection that this UI object will operate upon
|
|
//
|
|
// Arguments:
|
|
// pCon [in] LAN connection object to operate on. Can be NULL.
|
|
//
|
|
// Returns: S_OK if success, OLE error otherwise
|
|
//
|
|
// Author: danielwe 16 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::SetConnection(INetConnection* pCon)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
ReleaseObj(m_pconn);
|
|
m_pconn = pCon;
|
|
AddRefObj(m_pconn);
|
|
|
|
TraceError("CLanConnectionUi::SetConnection", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::Connect
|
|
//
|
|
// Purpose: Tells the connection to connect, optionally displaying UI of
|
|
// connection progress.
|
|
//
|
|
// Arguments:
|
|
// hwndParent [in] Parent window for UI
|
|
// dwFlags [in] Flags affecting how UI is shown
|
|
//
|
|
// Returns: S_OK if success, OLE error otherwise
|
|
//
|
|
// Author: danielwe 16 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::Connect(HWND hwndParent, DWORD dwFlags)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!m_pconn)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
CLanConnectionUiDlg dlg;
|
|
HWND hwndDlg;
|
|
|
|
if (!(dwFlags & NCUC_NO_UI))
|
|
{
|
|
// Display UI prior to connect
|
|
//
|
|
|
|
dlg.SetConnection(m_pconn);
|
|
hwndDlg = dlg.Create(hwndParent);
|
|
|
|
if (!hwndDlg)
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = m_pconn->Connect();
|
|
|
|
// Sleep a bit so they can read the text
|
|
Sleep(1000);
|
|
|
|
if (!(dwFlags & NCUC_NO_UI))
|
|
{
|
|
SetDlgItemText(hwndDlg, IDC_TXT_Caption, c_szEmpty);
|
|
Sleep(100);
|
|
|
|
UINT ids = SUCCEEDED(hr) ?
|
|
IDS_LAN_CONNECTED :
|
|
IDS_LAN_CONNECT_FAILED;
|
|
|
|
PCWSTR szwResult = SzLoadIds(ids);
|
|
SetDlgItemText(hwndDlg, IDC_TXT_Caption, szwResult);
|
|
|
|
// Sleep a bit so they can read the text
|
|
Sleep(1000);
|
|
|
|
DestroyWindow(hwndDlg);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
TraceHr(ttidError, FAL, hr, FALSE, "CLanConnectionUi::Connect");
|
|
return hr;
|
|
}
|
|
|
|
STDMETHODIMP CLanConnectionUi::Disconnect(HWND hwndParent, DWORD dwFlags)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!m_pconn)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
hr = m_pconn->Disconnect();
|
|
}
|
|
|
|
TraceHr (ttidError, FAL, hr, FALSE, "CLanConnectionUi::Disconnect");
|
|
return hr;
|
|
}
|
|
//+---------------------------------------------------------------------------
|
|
// INetConnectionPropertyUi
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::AddPages
|
|
//
|
|
// Purpose: Called when our UI object shoud add its pages to a property
|
|
// sheet for the connection UI owned by the shell.
|
|
//
|
|
// Arguments:
|
|
// pfnAddPage [in] Callback function to add the page
|
|
// lParam [in] User-defined paramter required by the callback
|
|
// function.
|
|
//
|
|
// Returns: S_OK if succeeded, otherwise OLE error.
|
|
//
|
|
// Author: danielwe 28 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::AddPages(HWND hwndParent,
|
|
LPFNADDPROPSHEETPAGE pfnAddPage,
|
|
LPARAM lParam)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!pfnAddPage)
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else if (!m_pconn)
|
|
{
|
|
hr = E_UNEXPECTED;
|
|
}
|
|
else
|
|
{
|
|
NETCON_PROPERTIES* pProperties;
|
|
hr = m_pconn->GetProperties(&pProperties);
|
|
if(SUCCEEDED(hr))
|
|
{
|
|
BOOL bShift = (0x8000 & GetKeyState(VK_SHIFT)); // ISSUE-2000/08/28-kenwic For debugging bridge bindings, remove before ship
|
|
if(!bShift && pProperties->MediaType == NCM_BRIDGE)
|
|
{
|
|
if (!m_pspNet)
|
|
{
|
|
m_pspNet = new CLanNetNetworkBridgePage(static_cast<INetConnectionPropertyUi *>(this),
|
|
m_pnc, m_pconn, m_fReadOnly, m_fNeedReboot,
|
|
m_fAccessDenied, g_aHelpIDs_IDD_LAN_NETWORKING);
|
|
}
|
|
|
|
if (m_pspNet)
|
|
{
|
|
(VOID) pfnAddPage(m_pspNet->CreatePage(IDD_LAN_NETWORKING_MACBRIDGE, 0),
|
|
lParam);
|
|
}
|
|
}
|
|
else if(!bShift && pProperties->dwCharacter & NCCF_BRIDGED)
|
|
{
|
|
if (!m_pspNet)
|
|
{
|
|
m_pspNet = new CLanNetBridgedPage(static_cast<INetConnectionPropertyUi *>(this),
|
|
m_pnc, m_pconn, m_fReadOnly, m_fNeedReboot,
|
|
m_fAccessDenied, g_aHelpIDs_IDD_LAN_NETWORKING);
|
|
}
|
|
|
|
if (m_pspNet)
|
|
{
|
|
(VOID) pfnAddPage(m_pspNet->CreatePage(IDD_LAN_NETWORKING_BRIDGED, 0),
|
|
lParam);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
if (!m_pspNet)
|
|
{
|
|
m_pspNet = new CLanNetNormalPage(static_cast<INetConnectionPropertyUi *>(this),
|
|
m_pnc, m_pconn, m_fReadOnly, m_fNeedReboot,
|
|
m_fAccessDenied, g_aHelpIDs_IDD_LAN_NETWORKING);
|
|
}
|
|
|
|
if (m_pspNet)
|
|
{
|
|
(VOID) pfnAddPage(m_pspNet->CreatePage(IDD_LAN_NETWORKING, 0),
|
|
lParam);
|
|
}
|
|
|
|
}
|
|
|
|
FreeNetconProperties(pProperties);
|
|
}
|
|
|
|
// display the "Wireless Zero Configuration" page
|
|
//
|
|
// for now (WinXP Client RTM) the decision was made to let everybody party, but based on
|
|
// the acl below. Later, the security schema won't change by default, but support will be
|
|
// added allowing admins to tighten up the access to the service RPC APIs.
|
|
if (m_pspWZeroConf==NULL /*&& FIsUserAdmin()*/)
|
|
{
|
|
m_pspWZeroConf = new CWZeroConfPage(static_cast<INetConnectionPropertyUi *>(this),
|
|
m_pnc, m_pconn , g_aHelpIDs_IDD_LAN_WZEROCONF);
|
|
// The page should show up only if the adapter is wireless and if
|
|
// the wzcsvc service is responding to calls.
|
|
if (!m_pspWZeroConf->IsWireless())
|
|
{
|
|
delete m_pspWZeroConf;
|
|
m_pspWZeroConf = NULL;
|
|
}
|
|
}
|
|
|
|
if (m_pspWZeroConf != NULL)
|
|
{
|
|
(VOID) pfnAddPage(
|
|
m_pspWZeroConf->CreatePage(
|
|
IDD_LAN_WZEROCONF,
|
|
0),
|
|
lParam);
|
|
}
|
|
|
|
//
|
|
// display the "Security" page
|
|
|
|
if (m_pspWZeroConf == NULL && !m_pspSecurity)
|
|
{
|
|
TraceTag (ttidLanUi, "OnInitDialog: Calling ElCanEapolRunOnInterface");
|
|
|
|
if (ElCanEapolRunOnInterface (m_pconn))
|
|
{
|
|
TraceTag (ttidLanUi, "OnInitDialog: Can surely display Authentication tab on interface");
|
|
m_pspSecurity = new CLanSecurityPage(static_cast<INetConnectionPropertyUi *>(this),
|
|
m_pnc, m_pconn,
|
|
g_aHelpIDs_IDD_SECURITY);
|
|
}
|
|
else
|
|
{
|
|
TraceTag (ttidLanUi, "OnInitDialog: Cannot display Authentication tab on interface");
|
|
}
|
|
}
|
|
|
|
if (m_pspSecurity)
|
|
{
|
|
(VOID) pfnAddPage(
|
|
m_pspSecurity->CreatePage(
|
|
IDD_LAN_SECURITY,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
WZCGetSPResModule()),
|
|
lParam);
|
|
}
|
|
|
|
// Check to see what homenet pages should be shown. These pages are
|
|
// never shown if the user is not an admin, as such a user will not
|
|
// have rights to modify the WMI store, which may be necessary just
|
|
// to retrieve the IHNetConnection
|
|
//
|
|
|
|
// (a) The page is not displayed unless the user is an admin
|
|
// or power-user, and the user has rights to share connections.
|
|
//
|
|
if (IsHNetAllowed(NCPERM_ShowSharedAccessUi) || IsHNetAllowed(NCPERM_PersonalFirewallConfig))
|
|
{
|
|
// (b) The page is not displayed unless TCP/IP is installed.
|
|
//
|
|
DWORD dwState;
|
|
if (SUCCEEDED(HrSvcQueryStatus(c_szTcpip, &dwState)) && dwState == SERVICE_RUNNING)
|
|
{
|
|
|
|
IHNetCfgMgr *pHNetCfgMgr;
|
|
IHNetIcsSettings *pHNetIcsSettings;
|
|
IHNetConnection *pHNConn;
|
|
|
|
hr = CoCreateInstance(
|
|
CLSID_HNetCfgMgr,
|
|
NULL,
|
|
CLSCTX_ALL,
|
|
IID_IHNetCfgMgr,
|
|
reinterpret_cast<void**>(&pHNetCfgMgr)
|
|
);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pHNetCfgMgr->QueryInterface(
|
|
__uuidof(pHNetIcsSettings),
|
|
reinterpret_cast<void**>(&pHNetIcsSettings)
|
|
);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = pHNetCfgMgr->GetIHNetConnectionForINetConnection(
|
|
m_pconn,
|
|
&pHNConn
|
|
);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
|
|
// display the 'Advanced' page if necessary
|
|
//
|
|
|
|
if (!m_pspAdvanced)
|
|
{
|
|
hr = HrQueryLanAdvancedPage(
|
|
m_pconn,
|
|
static_cast<INetConnectionPropertyUi *>(this),
|
|
m_pspAdvanced,
|
|
pHNetCfgMgr,
|
|
pHNetIcsSettings,
|
|
pHNConn);
|
|
}
|
|
if (m_pspAdvanced)
|
|
{
|
|
(VOID) pfnAddPage(
|
|
m_pspAdvanced->CreatePage(IDD_LAN_ADVANCED, 0),
|
|
lParam);
|
|
}
|
|
|
|
ReleaseObj(pHNConn);
|
|
}
|
|
|
|
ReleaseObj(pHNetIcsSettings);
|
|
}
|
|
|
|
ReleaseObj(pHNetCfgMgr);
|
|
}
|
|
|
|
if(FAILED(hr))
|
|
{
|
|
if(!m_pspHomenetUnavailable)
|
|
{
|
|
hr = HrCreateHomenetUnavailablePage(hr, m_pspHomenetUnavailable);
|
|
}
|
|
|
|
if (m_pspHomenetUnavailable)
|
|
{
|
|
(VOID) pfnAddPage(
|
|
m_pspHomenetUnavailable->CreatePage(IDD_LAN_HOMENETUNAVAILABLE, 0),
|
|
lParam);
|
|
}
|
|
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::AddPages(INetConnectionPropertyUi)", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// INetConnectionPropertyUi2
|
|
//
|
|
|
|
STDMETHODIMP
|
|
CLanConnectionUi::GetIcon (
|
|
DWORD dwSize,
|
|
HICON *phIcon )
|
|
{
|
|
HRESULT hr;
|
|
Assert (phIcon);
|
|
|
|
hr = HrGetIconFromMediaType(dwSize, NCM_LAN, NCSM_LAN, 7, 0, phIcon);
|
|
|
|
TraceError ("CLanConnectionUi::GetIcon (INetConnectionPropertyUi2)", hr);
|
|
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// INetConnectionWizardUi Methods
|
|
//
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::QueryMaxPageCount
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// pContext [in]
|
|
// pcMaxPages [out]
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: tongl 9 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::QueryMaxPageCount(INetConnectionWizardUiContext* pContext,
|
|
DWORD* pcMaxPages)
|
|
{
|
|
// Keep the pContext if we have not got one before
|
|
// for later use (to get the writable INetCfg *, for instance)
|
|
Assert(pContext);
|
|
Assert(pcMaxPages);
|
|
|
|
if (!m_pContext)
|
|
{
|
|
m_pContext = pContext;
|
|
AddRefObj(pContext);
|
|
}
|
|
|
|
*pcMaxPages = 1;
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::AddPages
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// INetConnectionWizardUiContext* pContext [in]
|
|
// LPFNADDPROPSHEETPAGE pfnAddPage [in]
|
|
// LPARAM lParam [in]
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: tongl 9 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::AddPages(INetConnectionWizardUiContext* pContext,
|
|
LPFNADDPROPSHEETPAGE lpfnAddPage,
|
|
LPARAM lParam)
|
|
{
|
|
// 1) Keep the pContext if we have not got one before
|
|
// for later use (to get the writable INetCfg *, for instance)
|
|
Assert(pContext);
|
|
if (!m_pContext)
|
|
{
|
|
m_pContext = pContext;
|
|
AddRefObj(pContext);
|
|
}
|
|
|
|
HPROPSHEETPAGE * ahpsp = NULL;
|
|
INT cPages = 0;
|
|
|
|
// 2) Call "lpfnAddPage(hpsp, lParam)" for every
|
|
// wizard page in the right order
|
|
|
|
// Get all wizard pages
|
|
|
|
// $REVIEW(tongl 10/30/97): With current design,
|
|
// LAN wizard has one page only
|
|
HRESULT hr = HrSetupWizPages(pContext, &ahpsp, &cPages);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
HPROPSHEETPAGE hpspCurrentPage = NULL;
|
|
|
|
while (cPages--)
|
|
{
|
|
hpspCurrentPage = *ahpsp;
|
|
ahpsp++;
|
|
|
|
// Add each wizard page
|
|
if (lpfnAddPage(hpspCurrentPage, lParam))
|
|
{
|
|
// We successfully made the hand off to the requestor
|
|
// Now we reset our handle so we don't try to free it
|
|
hpspCurrentPage = NULL;
|
|
}
|
|
|
|
// clean up if needed
|
|
if (hpspCurrentPage)
|
|
{
|
|
TraceError("CLanConnectionUi::AddPages, Failed to add one wizard page...", E_FAIL);
|
|
DestroyPropertySheetPage(hpspCurrentPage);
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::AddPages", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::GetSuggestedConnectionName
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// BSTR * bstrSuggestedName [out]
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: tongl 9 Dec 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::GetSuggestedConnectionName(
|
|
PWSTR* ppszwSuggestedName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// Validate parameters.
|
|
//
|
|
if (!ppszwSuggestedName)
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else
|
|
{
|
|
GUID guid;
|
|
hr = m_pnccAdapter->GetInstanceGuid(&guid);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LPWSTR szName;
|
|
CIntelliName Intelliname(_Module.GetResourceInstance(), NULL);
|
|
Intelliname.GenerateName(guid, NCM_LAN, 0, NULL, &szName);
|
|
|
|
hr = HrCoTaskMemAllocAndDupSz ( szName, ppszwSuggestedName);
|
|
LocalFree(szName);
|
|
}
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::GetSuggestedConnectionName", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::GetNewConnectionInfo
|
|
//
|
|
// Purpose: Allow provider control over renaming the current connection
|
|
// and the optional creation of connection shortcuts
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: scottbri 02 Feb 1998
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::GetNewConnectionInfo(
|
|
DWORD* pdwFlags,
|
|
NETCON_MEDIATYPE* pMediaType)
|
|
{
|
|
*pdwFlags = 0;
|
|
*pMediaType = NCM_LAN;
|
|
return S_OK;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::SetConnectionName
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// PCWSTR pszwConnectionName [in]
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: tongl 9 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::SetConnectionName(PCWSTR pszwConnectionName)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// 1) If the pointer is NULL or string is empty, return E_INVALIDAR
|
|
if ((!pszwConnectionName) || !wcslen(pszwConnectionName))
|
|
{
|
|
hr = E_INVALIDARG;
|
|
}
|
|
else
|
|
{
|
|
// 2) Otherwise, save the name to m_strConnectionName
|
|
|
|
// $REVIEW(tongl 12\23\97): Scott expects this function to return
|
|
// HRESULT_FROM_WIN32(ERROR_DUP_NAME)
|
|
// Here is what we are supposed to do:
|
|
// 1) Call HrIsConnectionNameUnique to determine if the name is unique
|
|
// 2) Call m_pLanConn->SetInfo if we have a valid connection already
|
|
// i.e. GetNewConnection has been called.
|
|
|
|
AssertSz(m_pnccAdapter, "How come we dont have the device yet ?");
|
|
|
|
if (m_pnccAdapter)
|
|
{
|
|
GUID guidConn;
|
|
|
|
hr = m_pnccAdapter->GetInstanceGuid(&guidConn);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = HrIsConnectionNameUnique(guidConn,
|
|
pszwConnectionName);
|
|
|
|
if (S_FALSE == hr) // is duplicate
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_DUP_NAME);
|
|
}
|
|
else if (S_OK == hr)
|
|
{
|
|
m_strConnectionName = pszwConnectionName;
|
|
|
|
if (m_pLanConn)
|
|
{
|
|
LANCON_INFO lci = {0};
|
|
lci.szwConnName = const_cast<PWSTR>(pszwConnectionName);
|
|
m_pLanConn->SetInfo(LCIF_NAME, &lci);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceErrorOptional("CLanConnectionUi::SetConnectionName", hr,
|
|
HRESULT_FROM_WIN32(ERROR_DUP_NAME) == hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::GetNewConnection
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// INetConnection** ppCon [out]
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
//
|
|
// Author: tongl 9 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::GetNewConnection(INetConnection** ppCon)
|
|
{
|
|
Assert (ppCon);
|
|
|
|
*ppCon = NULL;
|
|
|
|
// Enumerate existing connections and get the INetLanConnection *
|
|
// as follows:
|
|
// 1) If connection for the current m_pnccAdapter exists
|
|
// simply use the existing INetLanConnection *
|
|
// 2) If connection for the current m_pnccAdapter does not exist
|
|
// CreateInstance to get a new INetLanConnection *
|
|
|
|
INetLanConnection * pLanConn = NULL;
|
|
HRESULT hr = HrGetLanConnection(&pLanConn);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Call INetLanConnection::SetInfo if m_strConnName is not empty
|
|
Assert(pLanConn);
|
|
|
|
ReleaseObj(m_pLanConn);
|
|
m_pLanConn = pLanConn;
|
|
|
|
if (!m_strConnectionName.empty())
|
|
{
|
|
LANCON_INFO lci = {0};
|
|
lci.szwConnName = const_cast<PWSTR>(m_strConnectionName.c_str());
|
|
pLanConn->SetInfo(LCIF_NAME, &lci);
|
|
}
|
|
|
|
// Return the INetConnection pointer
|
|
hr = HrQIAndSetProxyBlanket(pLanConn, &ppCon);
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::GetNewConnection", hr);
|
|
return hr;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------
|
|
// INetLanConnectionWizardUi Methods
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::SetDeviceComponent
|
|
//
|
|
// Purpose:
|
|
//
|
|
// Arguments:
|
|
// GUID pguid [in]
|
|
//
|
|
// Returns: HRESULT, Error code.
|
|
// S_OK if the GUID matches a installed net device's GUID.
|
|
// E_FAIL if no match found.
|
|
//
|
|
// Author: tongl 19 Oct 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::SetDeviceComponent(const GUID * pguid)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
// AddPages must be called before SetDeviceComponent is called
|
|
AssertSz(m_pContext, "We do not have a valid context yet ?!");
|
|
|
|
if (!m_pnc)
|
|
{
|
|
hr = m_pContext->GetINetCfg(&m_pnc);
|
|
}
|
|
|
|
// Reset the adapter
|
|
ReleaseObj(m_pnccAdapter);
|
|
m_pnccAdapter = NULL;
|
|
|
|
// Reset the connection
|
|
ReleaseObj(m_pLanConn);
|
|
m_pLanConn = NULL;
|
|
|
|
// reset connection name
|
|
m_strConnectionName = c_szEmpty;
|
|
|
|
AssertSz(m_pnc, "Invalid INetCfg!");
|
|
|
|
// Note: pguid == NULL when the wizard is requesting the LAN adapter
|
|
// to release it's m_pnccAdapter and m_pLanConn members
|
|
//
|
|
if (SUCCEEDED(hr) && m_pnc && pguid)
|
|
{
|
|
// 1) Enumerate net adapters and try to find a match with the input GUID
|
|
// Save the adapter component in m_pnccAdapter
|
|
BOOL fFound = FALSE;
|
|
|
|
CIterNetCfgComponent nccIter(m_pnc, &GUID_DEVCLASS_NET);
|
|
INetCfgComponent* pnccAdapter = NULL;
|
|
|
|
while (!fFound && SUCCEEDED(hr) &&
|
|
(S_OK == (hr = nccIter.HrNext(&pnccAdapter))))
|
|
{
|
|
GUID guidDev;
|
|
hr = pnccAdapter->GetInstanceGuid(&guidDev);
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
if (*pguid == guidDev)
|
|
{
|
|
hr = HrIsLanCapableAdapter(pnccAdapter);
|
|
|
|
AssertSz((S_OK == hr), "Why is Lan wizard called on a non-Lan capable adapter ?");
|
|
|
|
if (S_OK == hr)
|
|
{
|
|
fFound = TRUE;
|
|
m_pnccAdapter = pnccAdapter;
|
|
AddRefObj(m_pnccAdapter);
|
|
}
|
|
}
|
|
}
|
|
ReleaseObj (pnccAdapter);
|
|
}
|
|
|
|
// 2) If we matched an adapter successfully, set it to the UI dialog
|
|
if ((fFound) && (S_OK == hr))
|
|
{
|
|
Assert(m_pnccAdapter);
|
|
|
|
if (m_pWizPage)
|
|
{
|
|
m_pWizPage->SetNetcfg(m_pnc);
|
|
m_pWizPage->SetAdapter(m_pnccAdapter);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hr = HRESULT_FROM_WIN32(ERROR_NOT_FOUND);
|
|
}
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::SetDeviceComponent", hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// INetLanConnectionUiInfo
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::GetDeviceGuid
|
|
//
|
|
// Purpose: Returns the device GUID associated with this connection
|
|
//
|
|
// Arguments:
|
|
// pguid [out] Returns GUID
|
|
//
|
|
// Returns: S_OK if success, OLE or Win32 error code otherwise
|
|
//
|
|
// Author: danielwe 13 Nov 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::GetDeviceGuid(GUID *pguid)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!pguid)
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else
|
|
{
|
|
// $REVIEW(tongl 11/29/97): when called from Lan wizard, the
|
|
// m_pconn has not been set yet, but the device guid is kept
|
|
// in m_pnccAdapter. So I added the if-else below.
|
|
if (m_pconn) // called from property UI
|
|
{
|
|
INetLanConnection * plan;
|
|
|
|
hr = HrQIAndSetProxyBlanket(m_pconn, &plan);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = plan->GetDeviceGuid(pguid);
|
|
ReleaseObj(plan);
|
|
}
|
|
}
|
|
else // called from wizard UI
|
|
{
|
|
AssertSz(m_pnccAdapter, "If called from wizard, the device should have been set.");
|
|
|
|
if (m_pnccAdapter)
|
|
{
|
|
m_pnccAdapter->GetInstanceGuid(pguid);
|
|
}
|
|
else
|
|
{
|
|
hr = E_FAIL;
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::GetDeviceGuid", hr);
|
|
return hr;
|
|
}
|
|
|
|
//
|
|
// INetConnectionUiLock
|
|
//
|
|
|
|
//+---------------------------------------------------------------------------
|
|
//
|
|
// Member: CLanConnectionUi::QueryLock
|
|
//
|
|
// Purpose: Causes the UI object to attempt to get the INetCfg write lock.
|
|
//
|
|
// Arguments:
|
|
// ppszwLockHolder [out] Description of component that holds the
|
|
// write lock in the event that it couldn't be
|
|
// obtained.
|
|
//
|
|
// Returns: S_OK if success, S_FALSE if write lock couldn't be obtained,
|
|
// OLE or Win32 error otherwise
|
|
//
|
|
// Author: danielwe 13 Nov 1997
|
|
//
|
|
// Notes:
|
|
//
|
|
STDMETHODIMP CLanConnectionUi::QueryLock(PWSTR* ppszwLockHolder)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!ppszwLockHolder)
|
|
{
|
|
hr = E_POINTER;
|
|
}
|
|
else
|
|
{
|
|
INetCfgLock * pnclock;
|
|
|
|
AssertSz(!m_pnc, "We're assuming this is in the property sheet "
|
|
"context and we don't yet have an INetCfg!");
|
|
|
|
*ppszwLockHolder = NULL;
|
|
|
|
// Instantiate an INetCfg
|
|
hr = CoCreateInstance(
|
|
CLSID_CNetCfg,
|
|
NULL,
|
|
CLSCTX_INPROC_SERVER | CLSCTX_NO_CODE_DOWNLOAD,
|
|
IID_INetCfg,
|
|
reinterpret_cast<LPVOID *>(&m_pnc));
|
|
|
|
TraceHr(ttidError, FAL, hr, FALSE, "CoCreateInstance");
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Get the locking interface
|
|
hr = m_pnc->QueryInterface(IID_INetCfgLock,
|
|
reinterpret_cast<LPVOID *>(&pnclock));
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
// Attempt to lock the INetCfg for read/write
|
|
hr = pnclock->AcquireWriteLock(0,
|
|
SzLoadIds(IDS_LANUI_LOCK_DESC), ppszwLockHolder);
|
|
|
|
ReleaseObj(pnclock);
|
|
|
|
if (NETCFG_E_NEED_REBOOT == hr)
|
|
{
|
|
// Can't make any changes because we are pending a reboot.
|
|
m_fReadOnly = TRUE;
|
|
m_fNeedReboot = TRUE;
|
|
hr = S_OK;
|
|
}
|
|
else if(E_ACCESSDENIED == hr)
|
|
{
|
|
// user not logged on as admin
|
|
//
|
|
m_fReadOnly = TRUE;
|
|
m_fAccessDenied = TRUE;
|
|
hr = S_OK;
|
|
}
|
|
else if (S_FALSE == hr)
|
|
{
|
|
// We don't have sufficent rights
|
|
//
|
|
m_fReadOnly = TRUE;
|
|
hr = S_OK;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
TraceError("CLanConnectionUi::QueryLock", (S_FALSE == hr) ? S_OK : hr);
|
|
return hr;
|
|
}
|