//+--------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1998.
//
// File: N C Q U E U E . C P P
//
// Contents: NetCfg queued installer actions
//
// Notes:
//
// Author: billbe 19 Aug 1998
//
//----------------------------------------------------------------------------
#include "pch.h"
#pragma hdrstop
#include "nceh.h"
#include "ncmisc.h"
#include "ncnetcfg.h"
#include "ncqueue.h"
#include "ncreg.h"
#include "ncsetup.h"
#include "ncui.h"
#include "wizentry.h"
const WCHAR c_szRegKeyNcQueue[] = L"SYSTEM\\CurrentControlSet\\Control\\Network\\NcQueue";
const DWORD c_cchQueueValueNameLen = 9;
const DWORD c_cbQueueValueNameLen = c_cchQueueValueNameLen * sizeof(WCHAR);
enum RO_ACTION
{
RO_ADD,
RO_CLEAR,
};
extern const WCHAR c_szRegValueNetCfgInstanceId[];
CRITICAL_SECTION g_csRefCount;
DWORD g_dwRefCount = 0;
HANDLE g_hLastThreadExitEvent;
DWORD WINAPI
InstallQueueWorkItem(PVOID pvContext);
inline VOID
IncrementRefCount()
{
EnterCriticalSection(&g_csRefCount);
// If 0 is the current count and we have an event to reset...
if (!g_dwRefCount && g_hLastThreadExitEvent)
{
ResetEvent(g_hLastThreadExitEvent);
}
++g_dwRefCount;
LeaveCriticalSection(&g_csRefCount);
}
inline VOID
DecrementRefCount()
{
EnterCriticalSection(&g_csRefCount);
--g_dwRefCount;
// If the count is 0 and we have an event to signal...
if (!g_dwRefCount && g_hLastThreadExitEvent)
{
SetEvent(g_hLastThreadExitEvent);
}
LeaveCriticalSection(&g_csRefCount);
}
//+---------------------------------------------------------------------------
//
// Function: WaitForInstallQueueToExit
//
// Purpose: This function waits until the last thread Called to continue processing the queue after processing was
// stopped due to a shutdown (of teh Netman service or system)
//
// Arguments:
// none
//
// Returns: nothing
//
// Author: billbe 8 Sep 1998
//
// Notes:
//
VOID
WaitForInstallQueueToExit()
{
// Wait on the event if it was successfully created.
if (g_hLastThreadExitEvent)
{
TraceTag(ttidInstallQueue, "Waiting on LastThreadExitEvent");
(VOID) WaitForSingleObject(g_hLastThreadExitEvent, INFINITE);
TraceTag(ttidInstallQueue, "Event signaled");
}
else
{
// If the event was not created, fall back to simply looping
// on the ref count
while (g_dwRefCount);
}
}
//+---------------------------------------------------------------------------
//
// Function: ProcessQueue
//
// Purpose: Called to continue processing the queue after processing was
// stopped due to a shutdown (of the Netman service or system)
//
// Arguments:
// none
//
// Returns: nothing
//
// Author: billbe 8 Sep 1998
//
// Notes:
//
EXTERN_C VOID WINAPI
ProcessQueue()
{
HRESULT hr;
INetInstallQueue* pniq;
BOOL fInitCom = TRUE;
TraceTag(ttidInstallQueue, "ProcessQueue called");
hr = CoInitializeEx(NULL, COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE);
if (RPC_E_CHANGED_MODE == hr)
{
hr = S_OK;
fInitCom = FALSE;
}
if (SUCCEEDED(hr))
{
// Create the install queue object and get the install queue interface
hr = CoCreateInstance(CLSID_InstallQueue, NULL,
CLSCTX_SERVER | CLSCTX_NO_CODE_DOWNLOAD,
IID_INetInstallQueue,
reinterpret_cast<LPVOID *>(&pniq));
if (S_OK == hr)
{
// Process whatever was left in the queue
//
pniq->ProcessItems();
pniq->Release();
}
if (fInitCom)
{
CoUninitialize();
}
}
}
//+---------------------------------------------------------------------------
//
// Function: RunOnceAddOrClearItem
//
// Purpose: Adds or clears an entry to/from the RunOnce registry key.
//
// Arguments:
// pszValueName [in] The value name of the run once item
// pszItemToRun [in] The actual command to "Run Once"
// eAction [in] RO_ADD to add the item, RO_CLEAR to clear the item.
//
// Returns: nothing
//
// Author: billbe 8 Sep 1998
//
// Notes:
//
VOID
RunOnceAddOrClearItem (
IN PCWSTR pszValueName,
IN PCWSTR pszItemToRun,
IN RO_ACTION eAction)
{
static const WCHAR c_szRegKeyRunOnce[] = L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\RunOnce";
HRESULT hr;
HKEY hkey;
// Open the RunOnce key
hr = HrRegOpenKeyEx (HKEY_LOCAL_MACHINE, c_szRegKeyRunOnce,
KEY_WRITE, &hkey);
if (S_OK == hr)
{
if (RO_ADD == eAction)
{
// Set the command line to run when the user logs in next.
(VOID) HrRegSetSz (hkey, pszValueName, pszItemToRun);
TraceTag(ttidInstallQueue, "Added %S RunOnce entry", pszValueName);
}
else if (RO_CLEAR == eAction)
{
// Remove the command line.
(VOID) HrRegDeleteValue (hkey, pszValueName);
TraceTag(ttidInstallQueue, "Cleared %S RunOnce entry", pszValueName);
}
RegCloseKey(hkey);
}
}
//+---------------------------------------------------------------------------
//
// Member: CInstallQueue::CInstallQueue
//
// Purpose: CInstall queue constructor
//
// Arguments:
// (none)
//
// Returns: nothing
//
// Author: BillBe 10 Sep 1998
//
// Notes:
//
CInstallQueue::CInstallQueue() :
m_dwNextAvailableIndex(0),
m_hkey(NULL),
m_nCurrentIndex(-1),
m_cItems(0),
m_aszItems(NULL),
m_cItemsToDelete(0),
m_aszItemsToDelete(NULL),
m_fQueueIsOpen(FALSE)
{
TraceTag(ttidInstallQueue, "Installer queue processor being created");
InitializeCriticalSection (&m_csReadLock);
InitializeCriticalSection (&m_csWriteLock);
InitializeCriticalSection (&g_csRefCount);
// Create an event that we will use to signal to interested parties
// that we are done. This is used by netman to wait for our threads
// to exit before destroying this object
g_hLastThreadExitEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
// If the event could not be created, we can still go on, we just won't
// use the event to signal our exit.
if (!g_hLastThreadExitEvent)
{
TraceTag(ttidInstallQueue, "Error creating last thread exit "
"event %d", GetLastError());
}
// Set the next available queue index so insertions won't overlap
SetNextAvailableIndex();
}
//+---------------------------------------------------------------------------
//
// Member: CInstallQueue::FinalRelease
//
// Purpose: COM destructor
//
// Arguments:
// (none)
//
// Returns: nothing
//
// Author: BillBe 10 Sep 1998
//
// Notes:
//
VOID
CInstallQueue::FinalRelease ()
{
DeleteCriticalSection (&m_csWriteLock);
DeleteCriticalSection (&m_csReadLock);
DeleteCriticalSection (&g_csRefCount);
}
// INetInstallQueue
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::AddItem
//
// Purpose: Add item to the queue
//
// Arguments:
// pGuid [in] The class guid of the device that was
// modified (installed. updated, or removed)
// pszDeviceInstanceId [in] The instance id of the device
// pszInfId [in] The inf id of the device
// dwCharacter [in] The device's characteristics
// eType [in] The install type (event) - indicates
// whether the device was installed, updated,
// or removed
//
// Returns: HRESULT. S_OK if successful, an error code otherwise.
//
// Author: billbe 25 Aug 1998
//
// Notes: If the device was removed, the device instance id will be the
// instance guid of the device. If the device was installed
// or updated then the id will be the PnP instance id
//
STDMETHODIMP
CInstallQueue::AddItem (
const NIQ_INFO* pInfo)
{
Assert(pInfo);
Assert(pInfo->pszPnpId);
Assert(pInfo->pszInfId);
if (!pInfo)
{
return E_POINTER;
}
if (!pInfo->pszPnpId)
{
return E_POINTER;
}
if (!pInfo->pszInfId)
{
return E_POINTER;
}
// Increment our refcount since we will be queueing a thread
IncrementRefCount();
// Add the item to the queue
HRESULT hr = HrAddItem (pInfo);
if (S_OK == hr)
{
// Start processing the queue on another thread
hr = HrQueueWorkItem();
}
TraceHr (ttidError, FAL, hr, FALSE, "CInstallQueue::AddItem");
return hr;
}
// CInstallQueue
//
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::HrQueueWorkItem
//
// Purpose: Start processing the queue on another thread
//
// Arguments:
// (none)
//
// Returns: HRESULT. S_OK if successful, an error code otherwise.
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
HRESULT
CInstallQueue::HrQueueWorkItem()
{
HRESULT hr = S_OK;
// Add ref our object since we will need it independent of whoever
// called us
AddRef();
// Queue a work item thread
if (!QueueUserWorkItem(InstallQueueWorkItem, this, WT_EXECUTEDEFAULT))
{
hr = HrFromLastWin32Error();
Release();
// The thread wasn't queued so reduce the ref count
DecrementRefCount();
}
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::SetNextAvailableIndex
//
// Purpose: Sets the member variable m_dwNextAvailableIndex to the next
// available queue position (registry valuename)
//
// Arguments:
// none
//
// Returns: nothing
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
VOID
CInstallQueue::SetNextAvailableIndex()
{
TraceTag(ttidInstallQueue, "Setting Next Available index");
EnterCriticalSection(&m_csWriteLock);
DWORD dwTempCount;
HKEY hkey;
// Open the NcQueue registry key
HRESULT hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyNcQueue,
KEY_QUERY_VALUE, &hkey);
if (S_OK == hr)
{
WCHAR szValueName[c_cchQueueValueNameLen];
DWORD cbValueName;
PWSTR pszStopString;
DWORD dwIndex = 0;
DWORD dwType;
do
{
cbValueName = c_cbQueueValueNameLen;
// Enumerate each value name
hr = HrRegEnumValue(hkey, dwIndex, szValueName, &cbValueName,
&dwType, NULL, NULL);
if (S_OK == hr)
{
// Convert the value name to a number
dwTempCount = wcstoul(szValueName, &pszStopString, c_nBase16);
// If the number is greater than our current count
// adjust the current count
if (dwTempCount >= m_dwNextAvailableIndex)
{
m_dwNextAvailableIndex = dwTempCount + 1;
}
}
++dwIndex;
} while (S_OK == hr);
if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
{
hr = S_OK;
}
RegCloseKey(hkey);
}
else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
{
hr = S_OK;
}
TraceTag(ttidInstallQueue, "Next Available index set %d", m_dwNextAvailableIndex);
LeaveCriticalSection(&m_csWriteLock);
}
// Compare strings given pointers to PCWSTRs
inline int __cdecl
iCompare(const void* ppszArg1, const void* ppszArg2)
{
return lstrcmpW(*((PCWSTR*)(void*)ppszArg1), *((PCWSTR*)(void*)ppszArg2));
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::PncqiCreateItem
//
// Purpose: Creates a queue item
//
// Arguments:
// pguidClass [in] The class guid of a device.
// pszDeviceInstanceId [in] The device id of the device.
// a pnp instance id if the device is being
// added or updated, a netcfg instance guid
// if it is being removed.
// pszInfId [in] The device's inf id.
// dwCharacter [in] The device's characteristics.
// eType [in] The notification for the item. Whether
// the device was installed, removed,
// or reinstalled.
//
// Returns: NCQUEUE_ITEM. The newly created item.
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
NCQUEUE_ITEM*
CInstallQueue::PncqiCreateItem(
const NIQ_INFO* pInfo)
{
Assert(pInfo);
Assert(pInfo->pszPnpId);
Assert(pInfo->pszInfId);
// The size of the item is the size of the structure plus the size of
// the device id we are appending to the structure
DWORD cbPnpId = CbOfSzAndTerm (pInfo->pszPnpId);
DWORD cbInfId = CbOfSzAndTerm (pInfo->pszInfId);
DWORD cbSize = sizeof(NCQUEUE_ITEM) + cbPnpId + cbInfId;
NCQUEUE_ITEM* pncqi = (NCQUEUE_ITEM*)MemAlloc(cbSize);
if (pncqi)
{
pncqi->cbSize = sizeof(NCQUEUE_ITEM);
pncqi->eType = pInfo->eType;
pncqi->dwCharacter = pInfo->dwCharacter;
pncqi->dwDeipFlags = pInfo->dwDeipFlags;
pncqi->cchPnpId = wcslen(pInfo->pszPnpId);
pncqi->cchInfId = wcslen(pInfo->pszInfId);
pncqi->ClassGuid = pInfo->ClassGuid;
pncqi->InstanceGuid = pInfo->InstanceGuid;
CopyMemory((BYTE*)pncqi + pncqi->cbSize, pInfo->pszPnpId, cbPnpId);
CopyMemory((BYTE*)pncqi + pncqi->cbSize + cbPnpId,
pInfo->pszInfId, cbInfId);
}
return pncqi;
}
//+---------------------------------------------------------------------------
//
// Function: HrAddItem
//
// Purpose: Worker function that adds an item to the queue
//
// Arguments:
// pguidClass [in] The class guid of a device
// pszwDeviceInstanceId [in] The device id of the device
// a pnp instance id if the device is being
// added or updated, a netcfg instance guid
// if it is being removed
// eType [in] The notification for the item. Whether the device
// was installed, removed, or reinstalled.
//
// Returns: HRESULT. S_OK if successful, an error code otherwise.
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
HRESULT
CInstallQueue::HrAddItem(
const NIQ_INFO* pInfo)
{
Assert(pInfo->pszPnpId);
Assert(pInfo->pszInfId);
EnterCriticalSection(&m_csWriteLock);
// Create the structure to be stored in the registry
NCQUEUE_ITEM* pncqi = PncqiCreateItem(pInfo);
// Open the NcQueue registry key
//
HKEY hkey;
HRESULT hr = HrRegCreateKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyNcQueue,
0, KEY_READ_WRITE, NULL, &hkey, NULL);
if (S_OK == hr && pncqi)
{
// Store the queue item under the next available valuename
//
WCHAR szValue[c_cchQueueValueNameLen];
wsprintfW(szValue, L"%.8X", m_dwNextAvailableIndex);
hr = HrRegSetValueEx(hkey, szValue, REG_BINARY, (BYTE*)pncqi,
DwSizeOfItem(pncqi));
if (S_OK == hr)
{
// Update the global count string
++m_dwNextAvailableIndex;
}
RegCloseKey(hkey);
}
MemFree(pncqi);
LeaveCriticalSection(&m_csWriteLock);
TraceError("CInstallQueue::HrAddItem", hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::DeleteMarkedItems
//
// Purpose: Deletes, from the registry, any values that have been
// marked for delete.
//
// Arguments:
// none
//
// Returns: nothing
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
VOID
CInstallQueue::DeleteMarkedItems()
{
Assert(m_hkey);
// If we have items to delete...
if (m_cItemsToDelete)
{
Assert(m_aszItemsToDelete);
// Remove each one from the registry
//
for (DWORD dw = 0; dw < m_cItemsToDelete; ++dw)
{
RegDeleteValue(m_hkey, m_aszItemsToDelete[dw]);
}
}
// Free the array and reset the pointer and counter
//
MemFree(m_aszItemsToDelete);
m_aszItemsToDelete = NULL;
m_cItemsToDelete = 0;
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::HrRefresh
//
// Purpose: Refreshs our snapshot of the queue.
//
// Arguments:
// none
//
// Returns: HRESULT. S_OK if successful and the queue has items,
// S_FALSE if the queue is empty,
// an error code otherwise.
///
// Author: billbe 25 Aug 1998
//
// Notes:
//
HRESULT
CInstallQueue::HrRefresh()
{
Assert(m_hkey);
// We don't want items being added to the queue while we are
// refreshing our snapshot, so we use a critical section to keep
// things
//
EnterCriticalSection(&m_csWriteLock);
// Do some housecleaning before the refresh
//
DeleteMarkedItems();
FreeAszItems();
// Retrieve the number of items in the queue
HRESULT hr = HrRegQueryInfoKey(m_hkey, NULL, NULL, NULL, NULL,
NULL, &m_cItems, NULL, NULL, NULL, NULL);
if (S_OK == hr)
{
Assert(0 <= (INT) m_cItems);
// If the queue is not empty...
if (0 < m_cItems)
{
DWORD cbValueLen;
// Allocate the array of pointers to strings for the items.
// Also, allocate the same quantity of pointers to hold
// items we will delete from the queue
DWORD cbArraySize = m_cItems * sizeof(PWSTR*);
m_aszItems =
reinterpret_cast<PWSTR*>(MemAlloc(cbArraySize));
if (m_aszItems)
{
m_aszItemsToDelete =
reinterpret_cast<PWSTR*>(MemAlloc(cbArraySize));
if (m_aszItemsToDelete)
{
// Store all the value names
// We will need to sort them so we can process each device in the
// correct order
//
DWORD dwType;
for (DWORD dw = 0; dw < m_cItems; ++dw)
{
m_aszItems[dw] =
reinterpret_cast<PWSTR>(MemAlloc(c_cbQueueValueNameLen));
if (m_aszItems[dw])
{
cbValueLen = c_cbQueueValueNameLen;
(void) HrRegEnumValue(m_hkey, dw,
m_aszItems[dw], &cbValueLen,
&dwType, NULL, NULL);
}
else
{
hr = E_OUTOFMEMORY;
}
}
// Sort the value names in ascending order. The value names
// are string versions of numbers padded to the left with zeroes
// e.g. 00000001
qsort(m_aszItems, m_cItems, sizeof(PWSTR), iCompare);
}
else
{
MemFree(m_aszItems);
hr = E_OUTOFMEMORY;
}
}
else
{
hr = E_OUTOFMEMORY;
}
}
else
{
// no items in the queue
hr = S_FALSE;
// The next items entered should start with valuename 00000000
m_dwNextAvailableIndex = 0;
}
}
else
{
// Refresh not possible so invalidate the key
RegCloseKey(m_hkey);
m_hkey = NULL;
}
// Reset Queue Index to just before the first element since
// retrieval is always done on the next element
m_nCurrentIndex = -1;
// Items can now be added to the queue
LeaveCriticalSection(&m_csWriteLock);
TraceError("CInstallQueue::HrRefresh",
(S_FALSE == hr) ? S_OK : hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::HrOpen
//
// Purpose: Opens the netcfg installer queue
//
// Arguments:
// None
//
// Returns: HRESULT. S_OK if successful and the queue has items,
// S_FALSE if the queue is empty,
// an error code otherwise.
//
// Author: billbe 25 Aug 1998
//
// Notes: When the queue is opened, it is a snapshot of the current queue
// state. i.e. items could be added after the fact. To refresh the
// snapshot, use RefreshQueue.
//
HRESULT
CInstallQueue::HrOpen()
{
HRESULT hr = S_OK;
// We don't want any other thread to process the queue since we will
// continue to retrieve new items that are added while we are
// processing the initial set
EnterCriticalSection(&m_csReadLock);
AssertSz(!m_hkey, "Reopening NcQueue without closing first!");
// We might have been waiting for a bit. Make sure the system
// is not shutting down before continuing
//
if (SERVICE_RUNNING == _Module.DwServiceStatus ())
{
hr = HrRegOpenKeyEx(HKEY_LOCAL_MACHINE, c_szRegKeyNcQueue,
KEY_ALL_ACCESS, &m_hkey);
if (S_OK == hr)
{
// Get a current snapshot of what's in the queue
// by refreshing
hr = HrRefresh();
if (SUCCEEDED(hr))
{
// The queue is officially open
m_fQueueIsOpen = TRUE;
}
}
}
else
{
TraceTag(ttidInstallQueue, "HrOpen::System is shutting down");
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
}
TraceError("CInstallQueue::HrOpen",
((S_FALSE == hr) ||
(HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS)) == hr) ?
S_OK : hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::Close
//
// Purpose: Closes the netcfg installer queue
//
// Arguments:
// None
//
// Returns: nothing
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
VOID
CInstallQueue::Close()
{
if (m_fQueueIsOpen)
{
// Housecleaning
//
// Delete anything so marked
DeleteMarkedItems();
// Free up the list of value names (aka queue items)
FreeAszItems();
RegSafeCloseKey(m_hkey);
m_hkey = NULL;
// Queue is now closed
m_fQueueIsOpen = FALSE;
}
// Other threads may have a chance at the queue now
LeaveCriticalSection(&m_csReadLock);
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::MarkCurrentItemForDeletion
//
// Purpose: Marks the current item for deletion from the registry
// when the queue is refreshed or closed
//
// Arguments:
// None
//
// Returns: nothing
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
VOID
CInstallQueue::MarkCurrentItemForDeletion()
{
AssertSz(FIsQueueIndexInRange(), "Queue index out of range");
if (FIsQueueIndexInRange())
{
// The number of items to delete should never exceed the number
// of queue items in our snapshot
if (m_cItemsToDelete < m_cItems)
{
// Just store a pointer, in m_aszItemsToDelete, to the value name
// pointed to by m_aszItems
//
m_aszItemsToDelete[m_cItemsToDelete] = m_aszItems[m_nCurrentIndex];
++m_cItemsToDelete;
}
else
{
TraceTag(ttidError, "Too many items marked for deletion");
}
}
}
//+---------------------------------------------------------------------------
//
// Function: CInstallQueue::HrGetNextItem
//
// Purpose: Get's the next item in the queue
//
// Arguments:
// None
//
// Returns: HRESULT. S_OK is successful,
// ERROR_NO_MORE_ITEMS (hresult version), if there are no
// more items in the queue. An error code otherwise.
//
// Author: billbe 25 Aug 1998
//
// Notes:
//
HRESULT
CInstallQueue::HrGetNextItem(NCQUEUE_ITEM** ppncqi)
{
Assert(ppncqi);
HRESULT hr;
// Increment index to the next value
++m_nCurrentIndex;
// If we haven't gone past the end of the queue...
if (FIsQueueIndexInRange())
{
// assign convenience pointer
PCWSTR pszItem = m_aszItems[m_nCurrentIndex];
DWORD cbData;
// Get the next queue item from the registry
//
hr = HrRegQueryValueEx(m_hkey, pszItem, NULL, NULL, &cbData);
if (S_OK == hr)
{
*ppncqi = (NCQUEUE_ITEM*)MemAlloc(cbData);
if( *ppncqi )
{
DWORD dwType;
hr = HrRegQueryValueEx(m_hkey, pszItem, &dwType,
(BYTE*)(*ppncqi), &cbData);
if (S_OK == hr)
{
Assert(REG_BINARY == dwType);
Assert((*ppncqi)->cchPnpId == (DWORD)
(wcslen((PWSTR)((BYTE*)(*ppncqi) +
(*ppncqi)->cbSize))));
Assert((*ppncqi)->cchInfId == (DWORD)
(wcslen((PWSTR)((BYTE*)(*ppncqi) +
(*ppncqi)->cbSize +
((*ppncqi)->cchPnpId + 1) * sizeof(WCHAR)))));
// change union variable from the count of characters
// to the actual string pointer
SetItemStringPtrs(*ppncqi);
}
else
{
MemFree(*ppncqi);
}
}
else
{
hr = E_OUTOFMEMORY;
}
}
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS);
}
TraceError("CInstallQueue::HrGetNextItem",
(HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr) ? S_OK : hr);
return hr;
}
//+---------------------------------------------------------------------------
//
// Function: EnumerateQueueItemsAndDoNotifications
//
// Purpose: Enumerates each item in the queue and notifies INetCfg
// of the modification (event)
//
// Arguments:
// pINetCfg [in] INetCfg interface
// pinq [in] The INetInstallQueue interface
// hdi [in] See Device Installer Api for more info
// pfReboot [out] TRUE if INetCfg requested a reboot,
// FALSE otherwise
//
// Returns: HRESULT. S_OK is successful, an error code otherwise
//
// Author: billbe 8 Sep 1998
//
// Notes:
//
BOOL
EnumerateQueueItemsAndDoNotifications(
INetCfg* pINetCfg,
INetCfgInternalSetup* pInternalSetup,
CInstallQueue* pniq,
HDEVINFO hdi,
BOOL* pfReboot)
{
Assert(pINetCfg);
Assert(pniq);
Assert(IsValidHandle(hdi));
Assert(pfReboot);
NCQUEUE_ITEM* pncqi;
SP_DEVINFO_DATA deid;
HRESULT hr;
BOOL fStatusOk = TRUE;
// Go through each item in the queue and add to INetCfg
//
while (S_OK == (hr = pniq->HrGetNextItem(&pncqi)))
{
// If we are not shutting down...
if (SERVICE_RUNNING == _Module.DwServiceStatus ())
{
if (NCI_INSTALL == pncqi->eType)
{
NIQ_INFO Info;
ZeroMemory(&Info, sizeof(Info));
Info.ClassGuid = pncqi->ClassGuid;
Info.InstanceGuid = pncqi->InstanceGuid;
Info.dwCharacter = pncqi->dwCharacter;
Info.dwDeipFlags = pncqi->dwDeipFlags;
Info.pszPnpId = pncqi->pszPnpId;
Info.pszInfId = pncqi->pszInfId;
NC_TRY
{
// Notify INetCfg
hr = HrDiAddComponentToINetCfg(
pINetCfg, pInternalSetup, &Info);
}
NC_CATCH_ALL
{
hr = E_UNEXPECTED;
}
}
else if (NCI_UPDATE == pncqi->eType)
{
pInternalSetup->EnumeratedComponentUpdated(pncqi->pszPnpId);
}
else if (NCI_REMOVE == pncqi->eType)
{
hr = pInternalSetup->EnumeratedComponentRemoved (
pncqi->pszPnpId);
}
if (SUCCEEDED(hr))
{
// Store the reboot result
if (NETCFG_S_REBOOT == hr)
{
*pfReboot = TRUE;
}
TraceTag(ttidInstallQueue, "Deleting item");
pniq->MarkCurrentItemForDeletion();
}
else
{
if (NETCFG_E_NEED_REBOOT == hr)
{
// Stop processing the queue since INetCfg will
// refuse updates.
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
fStatusOk = FALSE;
}
else if (HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) == hr)
{
// INetCfg couldn't find the adapter. Maybe someone
// removed it before we could notify INetCfg.
//
if (NCI_REMOVE != pncqi->eType)
{
HDEVINFO hdi;
SP_DEVINFO_DATA deid;
// Double check if the device is there.
// If it is, we need to remove it since INetCfg
// refuses to acknowledge its presence.
//
hr = HrSetupDiCreateDeviceInfoList (&pncqi->ClassGuid,
NULL, &hdi);
if (S_OK == hr)
{
hr = HrSetupDiOpenDeviceInfo (hdi,
pncqi->pszPnpId, NULL, 0, &deid);
if (S_OK == hr)
{
(VOID) HrSetupDiRemoveDevice (hdi, &deid);
}
SetupDiDestroyDeviceInfoList (hdi);
}
// Stop trying to notify INetCfg.
//
pniq->MarkCurrentItemForDeletion();
}
}
else
{
// Display message on error??
TraceHr (ttidError, FAL, hr, FALSE,
"EnumerateQueueItemsAndDoNotifications");
}
}
}
else
{
TraceTag(ttidInstallQueue, "System is shutting down during processing");
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
}
MemFree(pncqi);
if (HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS) == hr)
{
break;
}
}
// This error is expected when enumeration is complete
if (HRESULT_FROM_WIN32(ERROR_NO_MORE_ITEMS) == hr)
{
hr = S_OK;
}
TraceError("EnumerateQueueItemsAndDoNotifications", hr);
return fStatusOk;
}
//+---------------------------------------------------------------------------
//
// Function: InstallerQueueWorkItem
//
// Purpose: The LPTHREAD_START_ROUTINE passed to QueueUserWorkItem to
// handle the work of notifying INetCfg and the Connections
// wizard of an installation event.
//
// Arguments:
// pvContext [in] A pointer to a CInstallQueue class.
//
// Returns: NOERROR
//
// Author: billbe 25 Aug 1998
//
// Notes: The CInstallQueue was AddRef'd to insure its existence
// while we use it. This function must release it before
// exiting.
//
DWORD WINAPI
InstallQueueWorkItem(PVOID pvContext)
{
const WCHAR c_szInstallQueue[] = L"Install Queue";
const WCHAR c_szProcessQueue[] = L"rundll32 netman.dll,ProcessQueue";
const WCHAR c_szRegValueNcInstallQueue[] = L"NCInstallQueue";
CInstallQueue* pniq = reinterpret_cast<CInstallQueue*>(pvContext);
Assert(pniq);
BOOL fReboot = FALSE;
BOOL fInitCom = TRUE;
// We need to continue processing when the system is rebooted.
RunOnceAddOrClearItem (c_szRegValueNcInstallQueue,
c_szProcessQueue, RO_ADD);
HRESULT hr = CoInitializeEx (NULL,
COINIT_MULTITHREADED | COINIT_DISABLE_OLE1DDE);
if (RPC_E_CHANGED_MODE == hr)
{
hr = S_OK;
fInitCom = FALSE;
}
TraceHr (ttidError, FAL, hr, FALSE, "InstallQueueWorkItem: "
"CoInitializeEx failed");
if (SUCCEEDED(hr))
{
// Open the queue, this will give us a snapshot of what is in the queue
// at this time
hr = pniq->HrOpen();
if (S_OK == hr)
{
// Create an HDEVINFO
HDEVINFO hdi;
hr = HrSetupDiCreateDeviceInfoList(NULL, NULL, &hdi);
if (S_OK == hr)
{
INetCfg* pINetCfg;
INetCfgInternalSetup* pInternalSetup;
DWORD cmsTimeout = 500;
// As long as we are not shutting down. keep trying to get a
// writable INetCfg.
do
{
// Increase the time we wait each iteration.
cmsTimeout = cmsTimeout >= 512000 ? 512000 : cmsTimeout * 2;
// If we are not in the process of shutting down...
if (SERVICE_RUNNING == _Module.DwServiceStatus())
{
// Try to get a writable INetCfg
hr = HrCreateAndInitializeINetCfg(NULL, &pINetCfg,
TRUE, cmsTimeout, c_szInstallQueue, NULL);
if (NETCFG_E_NEED_REBOOT == hr)
{
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
break;
}
}
else
{
// Times up! Pencils down! Netman is shutting down
// we need to stop processing
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
break;
}
} while (FAILED(hr));
if (S_OK == hr)
{
hr = pINetCfg->QueryInterface (IID_INetCfgInternalSetup,
(void**)&pInternalSetup);
if (S_OK == hr)
{
// Go through the queue notifying interested modules
do
{
if (!EnumerateQueueItemsAndDoNotifications(pINetCfg,
pInternalSetup, pniq, hdi, &fReboot))
{
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
continue;
}
if (SERVICE_RUNNING == _Module.DwServiceStatus ())
{
TraceTag(ttidInstallQueue, "Refreshing queue");
// Check to see if any items were added to the queue
// after we started processing it
hr = pniq->HrRefresh();
if (S_FALSE == hr)
{
// We are finished so we can remove
// the entry in runonce that would
// start the queue processing on login.
RunOnceAddOrClearItem (
c_szRegValueNcInstallQueue,
c_szProcessQueue, RO_CLEAR);
}
}
else
{
hr = HRESULT_FROM_WIN32(ERROR_SHUTDOWN_IN_PROGRESS);
}
} while (S_OK == hr);
ReleaseObj (pInternalSetup);
}
(VOID) HrUninitializeAndReleaseINetCfg(FALSE, pINetCfg,
TRUE);
}
SetupDiDestroyDeviceInfoList(hdi);
}
}
// Close the queue
pniq->Close();
DecrementRefCount();
if (fInitCom)
{
CoUninitialize();
}
}
if (FAILED(hr))
{
// Display error.
}
// If a reboot is required and we are not in setup or already shutting
// down prompt the user.
//
if (fReboot && (SERVICE_RUNNING == _Module.DwServiceStatus()) &&
!FInSystemSetup())
{
// Handle reboot prompt
DWORD dwFlags = QUFR_REBOOT | QUFR_PROMPT;
(VOID) HrNcQueryUserForReboot(_Module.GetResourceInstance(),
NULL, IDS_INSTALLQUEUE_CAPTION,
IDS_INSTALLQUEUE_REBOOT_REQUIRED,
dwFlags);
}
TraceTag(ttidInstallQueue, "User Work Item Completed");
TraceError("InstallQueueWorkItem", (S_FALSE == hr) ? S_OK : hr);
return NOERROR;
}