windows-xp/Source/XPSP1/NT/net/config/netman/conman/conman.cpp

//+---------------------------------------------------------------------------
//
//  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