able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/net/config/shell/lanui/lanuiobj.cpp

992 lines
28 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// 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;
}
Reference in a new issue Copy permalink