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

1899 lines
61 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1997-2001.
//
// File: C O N M A N . C P P
//
// Contents: Connection manager.
//
// Notes:
//
// Author: shaunco 21 Sep 1997
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include <dbt.h>
#include <ndisguid.h>
#include "conman.h"
#include "dialup.h"
#include "enum.h"
#include "enumw.h"
#include "ncnetcon.h"
#include "ncreg.h"
#include "nminit.h"
#if DBG
#include "ncras.h"
#endif // DBG
#include <wmium.h>
#include "cmutil.h"
#include <shlwapi.h>
#include <shfolder.h>
#include "cobase.h"
#define SECURITY_WIN32
#include <security.h>
#include <wzcsvc.h>
bool operator < (const GUID& rguid1, const GUID& rguid2)
{
return memcmp(&rguid1, &rguid2, sizeof(GUID)) < 0;
}
static const WCHAR c_szRegKeyClassManagers [] = L"System\\CurrentControlSet\\Control\\Network\\Connections";
static const WCHAR c_szRegValClassManagers [] = L"ClassManagers";
volatile CConnectionManager* CConnectionManager::g_pConMan = NULL;
volatile BOOL CConnectionManager::g_fInUse = FALSE;
bool operator == (const NETCON_PROPERTIES& rProps1, const NETCON_PROPERTIES& rProps2)
{
return (IsEqualGUID(rProps1.clsidThisObject, rProps2.clsidThisObject) &&
IsEqualGUID(rProps1.clsidUiObject, rProps2.clsidUiObject) &&
(rProps1.dwCharacter == rProps2.dwCharacter) &&
IsEqualGUID(rProps1.guidId, rProps2.guidId) &&
(rProps1.MediaType == rProps2.MediaType) &&
(rProps1.pszwDeviceName == rProps2.pszwDeviceName) &&
(rProps1.pszwName == rProps2.pszwName) &&
(rProps1.Status == rProps2.Status));
}
const DWORD MAX_DISABLE_EVENT_TIMEOUT = 0xFFFF;
//static
BOOL
CConnectionManager::FHasActiveConnectionPoints ()
{
BOOL fRet = FALSE;
// Note our intent to use g_pConMan. We may find out that it is not
// available for use, but setting g_fInUse to TRUE prevents FinalRelease
// from allowing the object to be destroyed while we are using it.
//
g_fInUse = TRUE;
// Save g_pConMan into a local variable since we have to test and use
// it atomically. If we tested g_pConMan directly and then used it
// directly, it may have been set to NULL by FinalRelease in between
// our test and use. (Uh, which would be bad.)
//
// The const_cast is because g_pConMan is declared volatile.
//
CConnectionManager* pConMan = const_cast<CConnectionManager*>(g_pConMan);
if (pConMan)
{
pConMan->Lock();
IUnknown** ppUnk;
for (ppUnk = pConMan->m_vec.begin();
ppUnk < pConMan->m_vec.end();
ppUnk++)
{
if (ppUnk && *ppUnk)
{
fRet = TRUE;
break;
}
}
pConMan->Unlock();
}
// Now that we are finished using the object, indicate so. FinalRelease
// may be waiting for this condition in which case the object will soon
// be destroyed.
//
g_fInUse = FALSE;
return fRet;
}
//+---------------------------------------------------------------------------
//
// Member: CConnectionManager::FinalRelease
//
// Purpose: COM destructor
//
// Arguments:
// (none)
//
// Returns: nothing
//
// Author: shaunco 21 Sep 1997
//
// Notes:
//
VOID
CConnectionManager::FinalRelease ()
{
TraceFileFunc(ttidConman);
if (m_hRegClassManagerKey)
{
RegCloseKey(m_hRegClassManagerKey);
m_hRegClassManagerKey = NULL;
}
NTSTATUS Status = RtlDeregisterWait(m_hRegNotifyWait);
if (!NT_SUCCESS(Status))
{
TraceError("Could not deregister Registry Change Notification", HrFromLastWin32Error());
}
m_hRegNotifyWait = NULL;
if (m_hRegNotify)
{
CloseHandle(m_hRegNotify);
m_hRegNotify = NULL;
}
// Unregister for PnP device events if we successfully registered for
// them.
//
if (m_hDevNotify)
{
TraceTag (ttidConman, "Calling UnregisterDeviceNotification...");
if (!UnregisterDeviceNotification (m_hDevNotify))
{
TraceHr (ttidError, FAL, HrFromLastWin32Error(), FALSE,
"UnregisterDeviceNotification");
}
}
(VOID) HrEnsureRegisteredOrDeregisteredWithWmi (FALSE);
// Revoke the global connection manager pointer so that subsequent calls
// to NotifyClientsOfEvent on other threads will do nothing.
//
g_pConMan = NULL;
// Wait for g_fInUse to become FALSE. NotifyClientsOfEvent will set
// this to TRUE while it is using us.
// Keep track of the number of times we sleep and trace it for
// informational purposes. If we see that we are waiting quite a few
// number of times, increase the wait period.
//
#ifdef ENABLETRACE
if (g_fInUse)
{
TraceTag (ttidConman, "CConnectionManager::FinalRelease is waiting "
"for NotifyClientsOfEvent to finish...");
}
#endif
ULONG cSleeps = 0;
const DWORD nMilliseconds = 0;
while (g_fInUse)
{
cSleeps++;
Sleep (nMilliseconds);
}
#ifdef ENABLETRACE
if (cSleeps)
{
TraceTag (ttidConman, "CConnectionManager::FinalRelease slept %d "
"times. (%d ms each time.)",
cSleeps, nMilliseconds);
}
#endif
// Release our class managers.
//
for (CLASSMANAGERMAP::iterator iter = m_mapClassManagers.begin(); iter != m_mapClassManagers.end(); iter++)
{
ReleaseObj (iter->second);
}
TraceTag (ttidConman, "Connection manager being destroyed");
}
inline
LPVOID OffsetToPointer(LPVOID pStart, DWORD dwNumBytes)
{
DWORD_PTR dwPtr;
dwPtr = reinterpret_cast<DWORD_PTR>(pStart);
dwPtr += dwNumBytes;
return reinterpret_cast<LPVOID>(dwPtr);
}
//
// Must match type of NOTIFICATIONCALLBACK
//
VOID
WINAPI
WmiEventCallback (
PWNODE_HEADER Wnode,
UINT_PTR NotificationContext)
{
TraceTag (ttidConman,
"WmiEventCallback called...");
TraceTag(ttidEvents, "Flags: %d", Wnode->Flags);
if (WNODE_FLAG_SINGLE_INSTANCE == (WNODE_FLAG_SINGLE_INSTANCE & Wnode->Flags))
{
PWNODE_SINGLE_INSTANCE pInstance = reinterpret_cast<PWNODE_SINGLE_INSTANCE>(Wnode);
LPCWSTR lpszDevice = NULL;
LPWSTR lpszGuid;
GUID guidAdapter;
lpszDevice = reinterpret_cast<LPCWSTR>(OffsetToPointer(pInstance, pInstance->DataBlockOffset));
lpszGuid = wcsrchr(lpszDevice, L'{');
TraceTag(ttidEvents, "Adapter Guid From NDIS for Media Status Change Event: %S", lpszGuid);
if (SUCCEEDED(CLSIDFromString(lpszGuid, &guidAdapter)))
{
CONMAN_EVENT* pEvent;
pEvent = new CONMAN_EVENT;
if(pEvent)
{
pEvent->ConnectionManager = CONMAN_LAN;
pEvent->guidId = guidAdapter;
pEvent->Type = CONNECTION_STATUS_CHANGE;
if (IsEqualGUID(Wnode->Guid, GUID_NDIS_STATUS_MEDIA_CONNECT))
{
pEvent->Status = NCS_CONNECTED;
}
else if (IsEqualGUID(Wnode->Guid, GUID_NDIS_STATUS_MEDIA_DISCONNECT))
{
pEvent->Status = NCS_MEDIA_DISCONNECTED;
}
else
{
AssertSz(FALSE, "We never registered for this event ... WMI may be having internal issues.");
MemFree(pEvent);
return;
}
if (!QueueUserWorkItemInThread(LanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
FreeConmanEvent(pEvent);
}
}
}
}
else
{
LanEventNotify (REFRESH_ALL, NULL, NULL, NULL);
}
}
HRESULT
CConnectionManager::HrEnsureRegisteredOrDeregisteredWithWmi (
BOOL fRegister)
{
// Already registered or deregistered?
//
if (!!m_fRegisteredWithWmi == !!fRegister)
{
return S_OK;
}
m_fRegisteredWithWmi = !!fRegister;
HRESULT hr = S_OK;
DWORD dwErr;
INT i;
const GUID* apguid [] =
{
&GUID_NDIS_STATUS_MEDIA_CONNECT,
&GUID_NDIS_STATUS_MEDIA_DISCONNECT,
};
TraceTag (ttidConman,
"Calling WmiNotificationRegistration to %s for NDIS media events...",
(fRegister) ? "register" : "unregister");
for (i = 0; i < celems(apguid); i++)
{
dwErr = WmiNotificationRegistration (
const_cast<GUID*>(apguid[i]),
!!fRegister, // !! for BOOL to BOOLEAN
WmiEventCallback,
0,
NOTIFICATION_CALLBACK_DIRECT);
hr = HRESULT_FROM_WIN32 (dwErr);
TraceHr (ttidError, FAL, hr, FALSE, "WmiNotificationRegistration");
}
TraceHr (ttidError, FAL, hr, FALSE, "HrEnsureRegisteredOrDeregisteredWithWmi");
return hr;
}
//+---------------------------------------------------------------------------
//
// Member: CConnectionManager::NotifyClientsOfEvent
//
// Purpose: Notify our connection points that this object has changed
// state in some way and that a re-enumeration is needed.
//
// Arguments:
// (none)
//
// Returns: nothing
//
// Author: shaunco 20 Mar 1998
//
// Notes: This is a static function. No this pointer is passed.
//
// static
VOID CConnectionManager::NotifyClientsOfEvent (
CONMAN_EVENT* pEvent)
{
HRESULT hr;
// Let's be sure we only do work if the service state is still running.
// If we have a stop pending for example, we don't need to do anything.
//
if (SERVICE_RUNNING != _Module.DwServiceStatus ())
{
return;
}
// Note our intent to use g_pConMan. We may find out that it is not
// available for use, but setting g_fInUse to TRUE prevents FinalRelease
// from allowing the object to be destroyed while we are using it.
//
g_fInUse = TRUE;
// Save g_pConMan into a local variable since we have to test and use
// it atomically. If we tested g_pConMan directly and then used it
// directly, it may have been set to NULL by FinalRelease in between
// our test and use. (Uh, which would be bad.)
//
// The const_cast is because g_pConMan is declared volatile.
//
CConnectionManager* pConMan = const_cast<CConnectionManager*>(g_pConMan);
if (pConMan)
{
ULONG cpUnk;
IUnknown** apUnk;
hr = HrCopyIUnknownArrayWhileLocked (
pConMan,
&pConMan->m_vec,
&cpUnk,
&apUnk);
if (SUCCEEDED(hr) && cpUnk && apUnk)
{
#ifdef DBG
CHAR szClientList[MAX_PATH];
ZeroMemory(szClientList, MAX_PATH);
LPSTR pszClientList = szClientList;
ITERUSERNOTIFYMAP iter;
for (iter = pConMan->m_mapNotify.begin(); iter != pConMan->m_mapNotify.end(); iter++)
{
pszClientList += sprintf(pszClientList, "%d ", iter->second->dwCookie);
if (pszClientList > (szClientList + MAX_PATH-50) )
{
break;
}
}
if (iter != pConMan->m_mapNotify.end())
{
pszClientList += sprintf(pszClientList, "(more)");
}
TraceTag (ttidConman,
"NotifyClientsOfEvent: Notifying %d clients. Cookies: %s)",
cpUnk, szClientList);
#endif
for (ULONG i = 0; i < cpUnk; i++)
{
INetConnectionNotifySink* pSink = NULL;
BOOL fFireEventOnSink = FALSE;
hr = apUnk[i]->QueryInterface(IID_INetConnectionNotifySink, reinterpret_cast<LPVOID*>(&pSink));
ReleaseObj(apUnk[i]);
if (SUCCEEDED(hr))
{
hr = CoSetProxyBlanket (
pSink,
RPC_C_AUTHN_WINNT, // use NT default security
RPC_C_AUTHZ_NONE, // use NT default authentication
NULL, // must be null if default
RPC_C_AUTHN_LEVEL_CALL, // call
RPC_C_IMP_LEVEL_IDENTIFY,
NULL, // use process token
EOAC_DEFAULT);
switch (pEvent->Type)
{
case CONNECTION_ADDED:
Assert (pEvent);
Assert (pEvent->pPropsEx);
TraceTag(ttidEvents, "Characteristics: %s", DbgNccf(pEvent->pPropsEx->dwCharacter));
if (!(NCCF_ALL_USERS == (pEvent->pPropsEx->dwCharacter & NCCF_ALL_USERS)))
{
const WCHAR* pchw = reinterpret_cast<const WCHAR*>(pEvent->pPropsEx->bstrPersistData);
const WCHAR* pchwMax;
PCWSTR pszwPhonebook;
WCHAR LeadWord = PersistDataLead;
WCHAR TrailWord = PersistDataTrail;
IUnknown* pUnkSink = NULL;
hr = pSink->QueryInterface(IID_IUnknown, reinterpret_cast<LPVOID*>(&pUnkSink));
AssertSz(SUCCEEDED(hr), "Please explain how this happened...");
if (SUCCEEDED(hr))
{
// The last valid pointer for the embedded strings.
//
pchwMax = reinterpret_cast<const WCHAR*>(pEvent->pbPersistData + pEvent->cbPersistData
- (sizeof (GUID) +
sizeof (BOOL) +
sizeof (TrailWord)));
if (pchw && (LeadWord == *pchw))
{
TraceTag(ttidEvents, "Found Correct Lead Character.");
// Skip past our lead byte.
//
pchw++;
// Get PhoneBook path. Search for the terminating null and make sure
// we find it before the end of the buffer. Using lstrlen to skip
// the string can result in an an AV in the event the string is
// not actually null-terminated.
//
for (pszwPhonebook = pchw; *pchw != L'\0' ; pchw++)
{
if (pchw >= pchwMax)
{
pszwPhonebook = NULL;
break;
}
}
TraceTag(ttidEvents, "Found Valid Phonebook: %S", (pszwPhonebook) ? L"TRUE" : L"FALSE");
if (pszwPhonebook)
{
ITERUSERNOTIFYMAP iter = pConMan->m_mapNotify.find(pUnkSink);
if (iter != pConMan->m_mapNotify.end())
{
tstring& strUserDataPath = iter->second->szUserProfilesPath;
TraceTag(ttidEvents, "Comparing stored Path: %S to Phonebook Path: %S",
strUserDataPath.c_str(), pszwPhonebook);
if (_wcsnicmp(pszwPhonebook, strUserDataPath.c_str(), strUserDataPath.length()) == 0)
{
fFireEventOnSink = TRUE;
}
}
else
{
TraceTag(ttidError, "Could not find Path for NotifySink: 0x%08x", pUnkSink);
}
}
}
else
{
// Some other devices do not use this Format, but need to be sent events.
fFireEventOnSink = TRUE;
}
ReleaseObj(pUnkSink);
}
}
else
{
TraceTag(ttidEvents, "All User Connection");
fFireEventOnSink = TRUE;
}
if (fFireEventOnSink)
{
TraceTag (ttidEvents,
"Notifying ConnectionAdded... (pSink=0x%p)",
pSink);
hr = pSink->ConnectionAdded (
pEvent->pPropsEx);
}
break;
case CONNECTION_BANDWIDTH_CHANGE:
TraceTag (ttidEvents,
"Notifying ConnectionBandWidthChange... (pSink=0x%p)",
pSink);
hr = pSink->ConnectionBandWidthChange (&pEvent->guidId);
break;
case CONNECTION_DELETED:
TraceTag (ttidEvents,
"Notifying ConnectionDeleted... (pSink=0x%p)",
pSink);
hr = pSink->ConnectionDeleted (&pEvent->guidId);
break;
case CONNECTION_MODIFIED:
Assert (pEvent->pPropsEx);
TraceTag (ttidEvents,
"Notifying ConnectionModified... (pSink=0x%p)",
pSink);
hr = pSink->ConnectionModified (pEvent->pPropsEx);
break;
case CONNECTION_RENAMED:
TraceTag (ttidEvents,
"Notifying ConnectionRenamed... (pSink=0x%p)",
pSink);
hr = pSink->ConnectionRenamed (&pEvent->guidId,
pEvent->szNewName);
break;
case CONNECTION_STATUS_CHANGE:
TraceTag (ttidEvents,
"Notifying ConnectionStatusChange... (pSink=0x%p)",
pSink);
TraceTag(ttidEvents, "Status changed to: %s", DbgNcs(pEvent->Status));
hr = pSink->ConnectionStatusChange (&pEvent->guidId,
pEvent->Status);
break;
case REFRESH_ALL:
TraceTag (ttidEvents,
"Notifying RefreshAll... (pSink=0x%p)",
pSink);
hr = pSink->RefreshAll ();
break;
case CONNECTION_ADDRESS_CHANGE:
TraceTag (ttidEvents,
"Notifying ConnectionAddressChange... (pSink=0x%p)",
pSink);
hr = pSink->ConnectionAddressChange(&pEvent->guidId);
break;
case CONNECTION_BALLOON_POPUP:
TraceTag (ttidEvents,
"Notifying ConnectionStatusChange... (pSink=0x%p)",
pSink);
hr = pSink->ShowBalloon(&pEvent->guidId, pEvent->szCookie, pEvent->szBalloonText);
break;
case DISABLE_EVENTS:
TraceTag (ttidEvents,
"Notifying DisableEvents... (pSink=0x%p)",
pSink);
hr = pSink->DisableEvents(pEvent->fDisable, pEvent->ulDisableTimeout);
break;
default:
TraceTag(ttidEvents, "Event Type Passed: %d", pEvent->Type);
AssertSz (FALSE, "Invalid Type specified in pEvent");
break;
}
TraceErrorOptional("pSink call failed: ", hr, (S_FALSE == hr) );
if ( (HRESULT_FROM_WIN32(RPC_S_SERVER_UNAVAILABLE) == hr) ||
(HRESULT_FROM_WIN32(RPC_S_CALL_FAILED_DNE) == hr) ||
(RPC_E_SERVER_DIED == hr) ||
(RPC_E_DISCONNECTED == hr) ||
(HRESULT_FROM_WIN32(RPC_S_CALL_FAILED) == hr) )
{
IUnknown* pUnkSink = NULL;
HRESULT hrT = pSink->QueryInterface(IID_IUnknown, reinterpret_cast<LPVOID*>(&pUnkSink));
if (SUCCEEDED(hrT))
{
ITERUSERNOTIFYMAP iter = pConMan->m_mapNotify.find(pUnkSink);
if (iter != pConMan->m_mapNotify.end())
{
TraceTag(ttidError, "Dead client detected. Removing notify advise for: %S", iter->second->szUserName.c_str());
hrT = pConMan->Unadvise(iter->second->dwCookie);
}
ReleaseObj(pUnkSink);
}
TraceHr (ttidError, FAL, hrT, S_FALSE == hrT, "Error removing notify advise.");
}
ReleaseObj(pSink);
}
}
MemFree (apUnk);
}
}
// Now that we are finished using the object, indicate so. FinalRelease
// may be waiting for this condition in which case the object will soon
// be destroyed.
//
g_fInUse = FALSE;
}
//+---------------------------------------------------------------------------
//
// Member: CConnectionManager::HrEnsureClassManagersLoaded
//
// Purpose: Loads the class managers if they have not been loaded yet.
//
// Arguments:
// (none)
//
// Returns: S_OK or an error code.
//
// Author: shaunco 10 Dec 1997
//
// Notes:
//
HRESULT
CConnectionManager::HrEnsureClassManagersLoaded ()
{
HRESULT hr = S_OK;
// Need to protect m_mapClassManagers for the case that two clients
// get our object simultaneously and call a method which invokes
// this method. Need to transition m_mapClassManagers from being
// empty to being full in one atomic operation.
//
CExceptionSafeComObjectLock EsLock (this);
// If our vector of class managers is emtpy, try to load them.
// This will certainly be the case if we haven't tried to load them yet.
// If will also be the case when no class managers are registered.
// This isn't likely because we register them in hivesys.inf, but it
// shouldn't hurt to keep trying if they're really are none registered.
//
if (m_mapClassManagers.empty())
{
TraceTag (ttidConman, "Loading class managers...");
// Load the registered class managers.
//
// Open the registry key where the class managers are registered.
//
HKEY hkey;
hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE,
c_szRegKeyClassManagers, KEY_READ, &hkey);
if (SUCCEEDED(hr))
{
// Read the multi-sz of class manager CLSIDs.
//
PWSTR pmsz;
hr = HrRegQueryMultiSzWithAlloc (hkey, c_szRegValClassManagers,
&pmsz);
if (S_OK == hr)
{
(VOID) HrNmWaitForClassObjectsToBeRegistered ();
// For each CLSID, create the object and request its
// INetConnectionManager interface.
//
for (PCWSTR pszClsid = pmsz;
*pszClsid;
pszClsid += wcslen (pszClsid) + 1)
{
// Convert the string to a CLSID. If it fails, skip it.
//
CLSID clsid;
if (FAILED(CLSIDFromString ((LPOLESTR)pszClsid, &clsid)))
{
TraceTag (ttidConman, "Skipping bogus CLSID (%S)",
pszClsid);
continue;
}
// Create the class manager and add it to our list.
//
INetConnectionManager* pConMan;
hr = CoCreateInstance (
clsid, NULL,
CLSCTX_ALL | CLSCTX_NO_CODE_DOWNLOAD,
IID_INetConnectionManager,
reinterpret_cast<VOID**>(&pConMan));
TraceHr (ttidError, FAL, hr, FALSE,
"CConnectionManager::HrEnsureClassManagersLoaded: "
"CoCreateInstance failed for class manager %S.",
pszClsid);
if (SUCCEEDED(hr))
{
TraceTag (ttidConman, "Loaded class manager %S",
pszClsid);
Assert (pConMan);
if (m_mapClassManagers.find(clsid) != m_mapClassManagers.end())
{
AssertSz(FALSE, "Attempting to insert the same class manager twice!");
}
else
{
m_mapClassManagers[clsid] = pConMan;
}
}
/*
// If CoCreateInstance starts failing again on retail builds, this can
// be helpful.
else
{
CHAR psznBuf [512];
wsprintfA (psznBuf, "NETCFG: CoCreateInstance failed "
"(0x%08x) on class manager %i.\n",
hr, m_mapClassManagers.size ());
OutputDebugStringA (psznBuf);
}
*/
}
MemFree (pmsz);
}
RegCloseKey (hkey);
}
TraceTag (ttidConman, "Loaded %i class managers",
m_mapClassManagers.size ());
}
TraceErrorOptional ("CConnectionManager::HrEnsureClassManagersLoaded", hr, (S_FALSE == hr));
return hr;
}
VOID NTAPI CConnectionManager::RegChangeNotifyHandler(IN LPVOID pContext, IN BOOLEAN fTimerFired)
{
TraceTag(ttidConman, "CConnectionManager::RegChangeNotifyHandler (%d)", fTimerFired);
CConnectionManager *pThis = reinterpret_cast<CConnectionManager *>(pContext);
CExceptionSafeComObjectLock EsLock (pThis);
list<GUID> lstRegisteredGuids;
HKEY hkey;
HRESULT hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE, c_szRegKeyClassManagers, KEY_READ, &hkey);
if (SUCCEEDED(hr))
{
// Read the multi-sz of class manager CLSIDs.
//
PWSTR pmsz;
hr = HrRegQueryMultiSzWithAlloc (hkey, c_szRegValClassManagers,
&pmsz);
if (S_OK == hr)
{
for (PCWSTR pszClsid = pmsz;
*pszClsid;
pszClsid += wcslen (pszClsid) + 1)
{
CLSID clsid;
if (FAILED(CLSIDFromString ((LPOLESTR)pszClsid, &clsid)))
{
TraceTag (ttidConman, "Skipping bogus CLSID (%S)", pszClsid);
continue;
}
lstRegisteredGuids.push_back(clsid);
}
}
RegCloseKey(hkey);
BOOL bFound;
do
{
bFound = FALSE;
CLASSMANAGERMAP::iterator iterClassMgr;
for (iterClassMgr = pThis->m_mapClassManagers.begin(); iterClassMgr != pThis->m_mapClassManagers.end(); iterClassMgr++)
{
if (find(lstRegisteredGuids.begin(), lstRegisteredGuids.end(), iterClassMgr->first) == lstRegisteredGuids.end())
{
// Class manager key has been removed
TraceTag(ttidConman, "Removing class manager");
bFound = TRUE;
break;
}
}
if (bFound)
{
ULONG uRefCount = iterClassMgr->second->Release();
TraceTag(ttidConman, "Releasing class manager - Refcount = %d", uRefCount);
pThis->m_mapClassManagers.erase(iterClassMgr);
}
} while (bFound);
for (list<GUID>::iterator iter = lstRegisteredGuids.begin(); iter != lstRegisteredGuids.end(); iter++)
{
if (pThis->m_mapClassManagers.find(*iter) == pThis->m_mapClassManagers.end())
{
// Class manager key has been added
TraceTag(ttidConman, "Adding class manager");
INetConnectionManager* pConMan;
hr = CoCreateInstance (
*iter,
NULL,
CLSCTX_ALL | CLSCTX_NO_CODE_DOWNLOAD,
IID_INetConnectionManager,
reinterpret_cast<VOID**>(&pConMan));
TraceHr (ttidError, FAL, hr, FALSE,
"CConnectionManager::RegChangeNotifyHandler: CoCreateInstance failed for class manager.");
if (SUCCEEDED(hr))
{
TraceTag (ttidConman, "Loaded class manager");
Assert (pConMan);
if (pThis->m_mapClassManagers.find(*iter) != pThis->m_mapClassManagers.end())
{
AssertSz(FALSE, "Attempting to insert the same class manager twice!");
}
else
{
pThis->m_mapClassManagers[*iter] = pConMan;
}
}
}
}
}
else
{
TraceError("Could not open registry key", HrFromLastWin32Error());
}
TraceError("RegChangeNotifyHandler", hr);
LanEventNotify (REFRESH_ALL, NULL, NULL, NULL);
RegNotifyChangeKeyValue(pThis->m_hRegClassManagerKey, FALSE, REG_NOTIFY_CHANGE_LAST_SET, pThis->m_hRegNotify, TRUE);
}
//+---------------------------------------------------------------------------
// INetConnectionManager
//
//+---------------------------------------------------------------------------
//
// Member: CConnectionManager::EnumConnections
//
// Purpose: Return an INetConnection enumerator.
//
// Arguments:
// Flags [in]
// ppEnum [out] The enumerator.
//
// Returns: S_OK or an error code.
//
// Author: shaunco 21 Sep 1997
//
// Notes:
//
STDMETHODIMP
CConnectionManager::EnumConnections (
NETCONMGR_ENUM_FLAGS Flags,
IEnumNetConnection** ppEnum)
{
HRESULT hr = S_OK;
{
CExceptionSafeComObjectLock EsLock (this);
Assert(FImplies(m_hRegNotify, m_hRegClassManagerKey));
if (!m_hRegNotify)
{
m_hRegNotify = CreateEvent(NULL, FALSE, FALSE, NULL);
if (m_hRegNotify)
{
NTSTATUS Status = RtlRegisterWait(&m_hRegNotifyWait, m_hRegNotify, &CConnectionManager::RegChangeNotifyHandler, this, INFINITE, WT_EXECUTEDEFAULT);
if (!NT_SUCCESS(Status))
{
hr = HRESULT_FROM_NT(Status);
}
else
{
hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE, c_szRegKeyClassManagers, KEY_READ, &m_hRegClassManagerKey);
if (SUCCEEDED(hr))
{
hr = RegNotifyChangeKeyValue(m_hRegClassManagerKey, FALSE, REG_NOTIFY_CHANGE_LAST_SET, m_hRegNotify, TRUE);
if (FAILED(hr))
{
RegCloseKey(m_hRegClassManagerKey);
m_hRegClassManagerKey = NULL;
}
}
if (FAILED(hr))
{
Status = RtlDeregisterWait(m_hRegNotifyWait);
if (!NT_SUCCESS(Status))
{
hr = HRESULT_FROM_NT(Status);
}
m_hRegNotifyWait = NULL;
}
}
if (FAILED(hr))
{
CloseHandle(m_hRegNotify);
m_hRegNotify = NULL;
}
}
else
{
hr = HrFromLastWin32Error();
}
}
if (SUCCEEDED(hr))
{
// Create and return the enumerator.
//
hr = HrEnsureClassManagersLoaded ();
}
}
if(SUCCEEDED(hr))
{
hr = CConnectionManagerEnumConnection::CreateInstance (
Flags,
m_mapClassManagers,
IID_IEnumNetConnection,
reinterpret_cast<VOID**>(ppEnum));
}
TraceErrorOptional ("CConnectionManager::EnumConnections", hr, (S_FALSE == hr));
return hr;
}
//+---------------------------------------------------------------------------
// INetConnectionRefresh
//
STDMETHODIMP
CConnectionManager::RefreshAll()
{
LanEventNotify (REFRESH_ALL, NULL, NULL, NULL);
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::ConnectionAdded
//
// Purpose: Notifies event sinks that a new connection has been added.
//
// Arguments:
// pConnection [in] INetConnection* for new connection.
//
// Returns: Standard HRESULT
//
// Author: deonb 22 Mar 2001
//
// Notes:
//
STDMETHODIMP
CConnectionManager::ConnectionAdded(
IN INetConnection* pConnection)
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = CONNECTION_ADDED;
hr = HrGetPropertiesExFromINetConnection(pConnection, &pEvent->pPropsEx);
if (SUCCEEDED(hr))
{
if (QueueUserWorkItemInThread(ConmanEventWorkItem, pEvent, EVENTMGR_CONMAN))
{
return hr;
}
hr = E_FAIL;
}
FreeConmanEvent(pEvent);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::ConnectionDeleted
//
// Purpose: Sends an event to notify of a connection being deleted.
//
// Arguments:
// pguidId [in] GUID of the connectoid
//
// Returns: Standard HRESULT
//
// Author: ckotze 18 Apr 2001
//
// Notes:
//
STDMETHODIMP
CConnectionManager::ConnectionDeleted(
IN const GUID* pguidId)
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = CONNECTION_DELETED;
pEvent->guidId = *pguidId;
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
hr = E_FAIL;
FreeConmanEvent(pEvent);
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::ConnectionRenamed
//
// Purpose: Notifies the event sinks of a connection being renamed.
//
// Arguments:
// pConnection [in] INetConnection* for new connection.
//
// Returns: Standard HRESULT
//
// Author: ckotze 19 Apr 2001
//
// Notes:
//
STDMETHODIMP
CConnectionManager::ConnectionRenamed(
IN INetConnection* pConnection)
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = CONNECTION_RENAMED;
hr = HrGetPropertiesExFromINetConnection(pConnection, &pEvent->pPropsEx);
if (SUCCEEDED(hr))
{
lstrcpynW (pEvent->szNewName, pEvent->pPropsEx->bstrName, celems(pEvent->szNewName) );
pEvent->guidId = pEvent->pPropsEx->guidId;
if (QueueUserWorkItemInThread(ConmanEventWorkItem, pEvent, EVENTMGR_CONMAN))
{
return hr;
}
hr = E_FAIL;
}
FreeConmanEvent(pEvent);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::ConnectionModified
//
// Purpose: Sends an event to notify clients that the connection has been
// Modified.
// Arguments:
// pConnection [in] INetConnection* for new connection.
//
// Returns: Standard HRESULT
//
// Author: ckotze 22 Mar 2001
//
// Notes:
//
STDMETHODIMP
CConnectionManager::ConnectionModified(INetConnection* pConnection)
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = CONNECTION_MODIFIED;
hr = HrGetPropertiesExFromINetConnection(pConnection, &pEvent->pPropsEx);
if (SUCCEEDED(hr))
{
if (QueueUserWorkItemInThread(ConmanEventWorkItem, pEvent, EVENTMGR_CONMAN))
{
return hr;
}
hr = E_FAIL;
}
FreeConmanEvent(pEvent);
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::ConnectionStatusChanged
//
// Purpose: Sends the ShowBalloon event to each applicable netshell
//
// Arguments:
// pguidId [in] GUID of the connectoid
// ncs [in] New status of the connectoid
//
// Returns: Standard HRESULT
//
// Author: deonb 22 Mar 2001
//
// Notes:
//
STDMETHODIMP
CConnectionManager::ConnectionStatusChanged(
IN const GUID* pguidId,
IN const NETCON_STATUS ncs)
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = CONNECTION_STATUS_CHANGE;
pEvent->guidId = *pguidId;
pEvent->Status = ncs;
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
FreeConmanEvent(pEvent);
hr = E_FAIL;
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::ShowBalloon
//
// Purpose: Sends the ShowBalloon event to each applicable netshell
//
// Arguments:
// pguidId [in] GUID of the connectoid
// szCookie [in] A specified cookie that will end up at netshell
// szBalloonText [in] The balloon text
//
// Returns: Standard HRESULT
//
// Author: deonb 22 Mar 2001
//
// Notes:
//
STDMETHODIMP
CConnectionManager::ShowBalloon(
IN const GUID *pguidId,
IN const BSTR szCookie,
IN const BSTR szBalloonText)
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = CONNECTION_BALLOON_POPUP;
pEvent->guidId = *pguidId;
pEvent->szCookie = SysAllocStringByteLen(reinterpret_cast<LPCSTR>(szCookie), SysStringByteLen(szCookie));
pEvent->szBalloonText = SysAllocString(szBalloonText);
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
hr = E_FAIL;
FreeConmanEvent(pEvent);
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::DisableEvents
//
// Purpose: Disable netshell processing of events for x milliseconds
//
// Arguments:
// fDisable [in] TRUE to disable EVENT processing, FALSE to renable
// ulDisableTimeout [in] Number of milliseconds to disable event processing for
//
// Returns: Standard HRESULT
//
// Author: deonb 10 April 2001
//
// Notes:
//
STDMETHODIMP CConnectionManager::DisableEvents(IN const BOOL fDisable, IN const ULONG ulDisableTimeout)
{
HRESULT hr = S_OK;
if (ulDisableTimeout > MAX_DISABLE_EVENT_TIMEOUT)
{
return E_INVALIDARG;
}
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = DISABLE_EVENTS;
pEvent->fDisable = fDisable;
// We set the high bit to let netshell know that this is coming from our private interface.
pEvent->ulDisableTimeout = 0x80000000 | ulDisableTimeout;
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
hr = E_FAIL;
FreeConmanEvent(pEvent);
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::RefreshConnections
//
// Purpose: Refreshes the connections in the connections folder
//
// Arguments:
// None.
//
//
// Returns: Standard HRESULT
//
// Author: ckotze 19 April 2001
//
// Notes: This is a public interface that we are providing in order to
// allow other components/companies to have some control over
// the Connections Folder.
STDMETHODIMP CConnectionManager::RefreshConnections()
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = REFRESH_ALL;
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
hr = E_FAIL;
FreeConmanEvent(pEvent);
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::Enable
//
// Purpose: Enables events to be fired once more in the connections folder
//
// Arguments:
// None.
//
// Returns: Standard HRESULT
//
// Author: ckotze 19 April 2001
//
// Notes: This is a public interface that we are providing in order to
// allow other components/companies to have some control over
// the Connections Folder.
// Since this is a public interface, we are only allowing the
// INVALID_ADDRESS notification to be disabled
// (this will take place in netshell.dll).
//
STDMETHODIMP CConnectionManager::Enable()
{
HRESULT hr = S_OK;
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = DISABLE_EVENTS;
pEvent->fDisable = FALSE;
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
hr = E_FAIL;
FreeConmanEvent(pEvent);
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CConnectionManager::Disable
//
// Purpose: Disable netshell processing of events for x milliseconds
//
// Arguments:
// ulDisableTimeout [in] Number of milliseconds to disable event
// processing for. Max is 60000 (1 minute)
//
// Returns: Standard HRESULT
//
// Author: ckotze 19 April 2001
//
// Notes: This is a public interface that we are providing in order to
// allow other components/companies to have some control over
// the Connections Folder.
// Since this is a public interface, we are only allowing the
// INVALID_ADDRESS notification to be disabled
// (this will take place in netshell.dll).
//
STDMETHODIMP CConnectionManager::Disable(IN const ULONG ulDisableTimeout)
{
HRESULT hr = S_OK;
if (ulDisableTimeout > MAX_DISABLE_EVENT_TIMEOUT)
{
return E_INVALIDARG;
}
CONMAN_EVENT* pEvent = new CONMAN_EVENT;
if (pEvent)
{
ZeroMemory(pEvent, sizeof(CONMAN_EVENT));
pEvent->Type = DISABLE_EVENTS;
pEvent->fDisable = TRUE;
pEvent->ulDisableTimeout = ulDisableTimeout;
if (!QueueUserWorkItemInThread(ConmanEventWorkItem, reinterpret_cast<PVOID>(pEvent), EVENTMGR_CONMAN))
{
hr = E_FAIL;
FreeConmanEvent(pEvent);
}
}
else
{
hr = E_OUTOFMEMORY;
}
return hr;
}
//+---------------------------------------------------------------------------
// INetConnectionCMUtil
//
//+---------------------------------------------------------------------------
//
// Function: MapCMHiddenConnectionToOwner
//
// Purpose: Maps a child connection to its parent connection.
//
// Connection Manager has two stages: Dialup and VPN.
// For the Dialup it creates a hidden connectoid that the
// folder (netshell) does not see. However netman caches
// the name, guid and status of this connectedoid. Both
// the parent and child connectoid have the same name. When
// the status of the hidden connectiod is updated the folder
// recives the guid of the hidden connectoid and maps the
// connectiod to it parent (Connection Manager) by searching
// netmans cache for the name of the hidden connectoid. Then it
// searches the connections in the folder for that name and thus
// gets the guid of the parent connectoid.
//
// When the folder gets a notify message from netman for the hidden
// connection it uses this function to find the parent and update the
// parent's status. The hidden connection is not displayed.
//
// Arguments:
// guidHidden [in] GUID of the hidden connectiod
// pguidOwner [out] GUID of the parent connectiod
//
// Returns: S_OK -- Found hidden connection
// else not found
//
// Author: omiller 1 Jun 2000
//
// Notes:
//
STDMETHODIMP
CConnectionManager::MapCMHiddenConnectionToOwner (
/*[in]*/ REFGUID guidHidden,
/*[out]*/ GUID * pguidOwner)
{
HRESULT hr = S_OK;
bool bFound = false;
hr = HrEnsureClassManagersLoaded ();
if (SUCCEEDED(hr))
{
// Impersonate the user so that we see all of the connections displayed in the folder
//
hr = CoImpersonateClient();
if (SUCCEEDED(hr))
{
// Find the hidden connection with this guid
//
CMEntry cm;
hr = CCMUtil::Instance().HrGetEntry(guidHidden, cm);
// Did we find the hidden connection?
if( S_OK == hr )
{
// Enumerate through all of the connections and find connection with the same name as the
// hidden connection
//
IEnumNetConnection * pEnum = NULL;
hr = CWanConnectionManagerEnumConnection::CreateInstance(NCME_DEFAULT, IID_IEnumNetConnection, reinterpret_cast<LPVOID *>(&pEnum));
if (SUCCEEDED(hr))
{
INetConnection * pNetCon;
NETCON_PROPERTIES * pProps;
while(!bFound)
{
// Get the nect connection
//
hr = pEnum->Next(1, &pNetCon, NULL);
if(S_OK != hr)
{
// Ooops encountered some error, stop searching
//
break;
}
// Get the properties of the connection
//
hr = pNetCon->GetProperties(&pProps);
if(SUCCEEDED(hr))
{
if(lstrcmp(cm.m_szEntryName, pProps->pszwName) == 0)
{
// Found the connection that has the same name a the hidden connection
// Stop searching!!
*pguidOwner = pProps->guidId;
bFound = true;
}
FreeNetconProperties(pProps);
}
ReleaseObj(pNetCon);
}
ReleaseObj(pEnum);
}
}
// Stop Impersonating the user
//
CoRevertToSelf();
}
}
return bFound ? S_OK : S_FALSE;
}
//+---------------------------------------------------------------------------
// IConnectionPoint overrides netman!CConnectionManager__Advise
//
STDMETHODIMP
CConnectionManager::Advise (
IUnknown* pUnkSink,
DWORD* pdwCookie)
{
HRESULT hr = S_OK;
TraceFileFunc(ttidConman);
Assert(!FBadInPtr(pUnkSink));
// Set our cloaked identity to be used when we call back on this
// advise interface. It's important to do this for security. Since
// we run as LocalSystem, if we were to call back without identify
// impersonation only, the client could impersonate us and get a free
// LocalSystem context which could be used for malicious purposes.
//
//
CoSetProxyBlanket (
pUnkSink,
RPC_C_AUTHN_WINNT, // use NT default security
RPC_C_AUTHZ_NONE, // use NT default authentication
NULL, // must be null if default
RPC_C_AUTHN_LEVEL_CALL, // call
RPC_C_IMP_LEVEL_IDENTIFY,
NULL, // use process token
EOAC_DEFAULT);
TraceHr(ttidError, FAL, hr, FALSE, "CoSetProxyBlanket");
if (S_OK == hr)
{
// Initialize our event handler if it has not already been done.
hr = HrEnsureEventHandlerInitialized();
if (SUCCEEDED(hr))
{
// We still work for other events if this fails.
hr = HrEnsureRegisteredWithNla();
TraceErrorOptional("Could not register with Nla", hr, (S_FALSE == hr));
// Call the underlying ATL implementation of Advise.
//
hr = IConnectionPointImpl<
CConnectionManager,
&IID_INetConnectionNotifySink>::Advise(pUnkSink, pdwCookie);
TraceTag (ttidConman,
"CConnectionManager::Advise called... pUnkSink=0x%p, cookie=%d",
pUnkSink,
*pdwCookie);
TraceHr (ttidError, FAL, hr, FALSE, "IConnectionPointImpl::Advise");
if (SUCCEEDED(hr))
{
WCHAR szUserAppData[MAX_PATH];
HRESULT hrT = S_OK;
HRESULT hrImpersonate = S_OK;
if (SUCCEEDED(hrT))
{
// We ignore this HRESULT because we can be called inproc and that would definitely fail.
// Instead we just make sure that it succeeded when befor call CoRevertToSelf. This is
// fine because we'll still get a valid User App data path, it will just be something like
// LocalService or LocalSystem and we can still determine which sinks to send events to.
BOOLEAN fNotifyWZC = FALSE;
WCHAR szUserName[MAX_PATH];
CNotifySourceInfo* pNotifySourceInfo = new CNotifySourceInfo();
if (!pNotifySourceInfo)
{
hr = E_OUTOFMEMORY;
}
else
{
pNotifySourceInfo->dwCookie = *pdwCookie;
hrImpersonate = CoImpersonateClient();
if (SUCCEEDED(hrImpersonate) || (RPC_E_CALL_COMPLETE == hrImpersonate))
{
hrT = SHGetFolderPath(NULL, CSIDL_APPDATA, NULL, 0, szUserAppData);
if (SUCCEEDED(hrT))
{
pNotifySourceInfo->szUserProfilesPath = szUserAppData;
TraceTag(ttidEvents, "Adding IUnknown for Sink to Map: 0x%08x. Path: %S", reinterpret_cast<DWORD_PTR>(pUnkSink), szUserAppData);
TraceTag(ttidEvents, "Number of Items in Map: %d", m_mapNotify.size());
}
else
{
TraceError("Unable to get Folder Path", hrT);
}
ZeroMemory(szUserName, celems(szUserName));
ULONG nSize = celems(szUserName);
if (GetUserNameEx(NameSamCompatible, szUserName, &nSize) && *szUserName)
{
pNotifySourceInfo->szUserName = szUserName;
fNotifyWZC = TRUE;
}
else
{
pNotifySourceInfo->szUserName = L"System";
TraceError("Unable to get the user name", HrFromLastWin32Error());
}
}
Lock();
m_mapNotify[pUnkSink] = pNotifySourceInfo;
Unlock();
#ifdef DBG
LPWSTR* ppszAdviseUsers;
DWORD dwCount;
HRESULT hrT = GetClientAdvises(&ppszAdviseUsers, &dwCount);
if (SUCCEEDED(hrT))
{
Assert(dwCount);
TraceTag(ttidConman, "Advise client list after ::Advise:");
for (DWORD x = 0; x < dwCount; x++)
{
LPWSTR szUserName = ppszAdviseUsers[x];
TraceTag(ttidConman, "%x: %S", x, szUserName);
}
CoTaskMemFree(ppszAdviseUsers);
}
#endif
}
if (SUCCEEDED(hrImpersonate))
{
CoRevertToSelf();
}
if (fNotifyWZC)
{
WZCTrayIconReady(szUserName);
}
}
if (!m_lRegisteredOneTime)
{
// Do an explicit interlocked exchange to only let one thread
// through to do the registration.
//
if (0 == InterlockedExchange (&m_lRegisteredOneTime, 1))
{
// Register for device notifications. Specifically, we're
// interested in network adapters coming and going. If this
// fails, we proceed anyway.
//
TraceTag (ttidConman, "Calling RegisterDeviceNotification...");
DEV_BROADCAST_DEVICEINTERFACE PnpFilter;
ZeroMemory (&PnpFilter, sizeof(PnpFilter));
PnpFilter.dbcc_size = sizeof(PnpFilter);
PnpFilter.dbcc_devicetype = DBT_DEVTYP_DEVICEINTERFACE;
PnpFilter.dbcc_classguid = GUID_NDIS_LAN_CLASS;
m_hDevNotify = RegisterDeviceNotification (
(HANDLE)_Module.m_hStatus,
&PnpFilter,
DEVICE_NOTIFY_SERVICE_HANDLE);
if (!m_hDevNotify)
{
TraceHr (ttidError, FAL, HrFromLastWin32Error(), FALSE,
"RegisterDeviceNotification");
}
(VOID) HrEnsureRegisteredOrDeregisteredWithWmi (TRUE);
}
}
}
}
}
TraceErrorOptional ("CConnectionManager::Advise", hr, (S_FALSE == hr));
return hr;
}
STDMETHODIMP
CConnectionManager::Unadvise(DWORD dwCookie)
{
HRESULT hr = S_OK;
TraceFileFunc(ttidConman);
hr = IConnectionPointImpl<CConnectionManager, &IID_INetConnectionNotifySink>::Unadvise(dwCookie);
Lock();
BOOL fFound = FALSE;
for (ITERUSERNOTIFYMAP iter = m_mapNotify.begin(); iter != m_mapNotify.end(); iter++)
{
if (iter->second->dwCookie == dwCookie)
{
fFound = TRUE;
delete iter->second;
m_mapNotify.erase(iter);
break;
}
}
Unlock();
if (!fFound)
{
TraceTag(ttidError, "Unadvise cannot find advise for cookie 0x%08x in notify map", dwCookie);
}
#ifdef DBG
LPWSTR* ppszAdviseUsers;
DWORD dwCount;
HRESULT hrT = GetClientAdvises(&ppszAdviseUsers, &dwCount);
if (SUCCEEDED(hrT))
{
if (!dwCount)
{
TraceTag(ttidConman, "Unadvise removed the last advise client");
}
else
{
TraceTag(ttidConman, "Advise client list after ::Unadvise:");
}
for (DWORD x = 0; x < dwCount; x++)
{
LPWSTR szUserName = ppszAdviseUsers[x];
TraceTag(ttidConman, "%x: %S", x, szUserName);
}
CoTaskMemFree(ppszAdviseUsers);
}
#endif
return hr;
}
#if DBG
//+---------------------------------------------------------------------------
// INetConnectionManagerDebug
//
DWORD
WINAPI
ConmanNotifyTest (
PVOID pvContext
)
{
HRESULT hr;
RASENUMENTRYDETAILS* pDetails;
DWORD cDetails;
hr = HrRasEnumAllEntriesWithDetails (NULL,
&pDetails, &cDetails);
if (SUCCEEDED(hr))
{
RASEVENT Event;
for (DWORD i = 0; i < cDetails; i++)
{
Event.Type = ENTRY_ADDED;
Event.Details = pDetails[i];
RasEventNotify (&Event);
Event.Type = ENTRY_MODIFIED;
RasEventNotify (&Event);
Event.Type = ENTRY_CONNECTED;
Event.guidId = pDetails[i].guidId;
RasEventNotify (&Event);
Event.Type = ENTRY_DISCONNECTED;
Event.guidId = pDetails[i].guidId;
RasEventNotify (&Event);
Event.Type = ENTRY_RENAMED;
lstrcpyW (Event.pszwNewName, L"foobar");
RasEventNotify (&Event);
Event.Type = ENTRY_DELETED;
Event.guidId = pDetails[i].guidId;
RasEventNotify (&Event);
}
MemFree (pDetails);
}
LanEventNotify (REFRESH_ALL, NULL, NULL, NULL);
TraceErrorOptional ("ConmanNotifyTest", hr, (S_FALSE == hr));
return hr;
}
STDMETHODIMP
CConnectionManager::NotifyTestStart ()
{
HRESULT hr = S_OK;
if (!QueueUserWorkItem (ConmanNotifyTest, NULL, WT_EXECUTEDEFAULT))
{
hr = HrFromLastWin32Error ();
}
TraceErrorOptional ("CConnectionManager::NotifyTestStart", hr, (S_FALSE == hr));
return hr;
}
STDMETHODIMP
CConnectionManager::NotifyTestStop ()
{
return S_OK;
}
#endif // DBG
Reference in a new issue Copy permalink