889 lines
20 KiB
C
889 lines
20 KiB
C
//+-------------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (C) Microsoft Corporation, 1997 - 1999
|
|
//
|
|
// File: miscutil.c
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
#include "HdwWiz.h"
|
|
|
|
|
|
/* ----------------------------------------------------------------------
|
|
* SetDlgText - Set Dialog Text Field
|
|
*
|
|
* Concatenates a number of string resources and does a SetWindowText()
|
|
* for a dialog text control.
|
|
*
|
|
* Parameters:
|
|
*
|
|
* hDlg - Dialog handle
|
|
* iControl - Dialog control ID to receive text
|
|
* nStartString - ID of first string resource to concatenate
|
|
* nEndString - ID of last string resource to concatenate
|
|
*
|
|
* Note: the string IDs must be consecutive.
|
|
*/
|
|
|
|
void
|
|
SetDlgText(HWND hDlg, int iControl, int nStartString, int nEndString)
|
|
{
|
|
int iX;
|
|
TCHAR szText[MAX_PATH*4];
|
|
|
|
szText[0] = '\0';
|
|
for (iX = nStartString; iX<= nEndString; iX++) {
|
|
|
|
LoadString(hHdwWiz,
|
|
iX,
|
|
szText + lstrlen(szText),
|
|
sizeof(szText)/sizeof(TCHAR) - lstrlen(szText)
|
|
);
|
|
}
|
|
|
|
if (iControl) {
|
|
|
|
SetDlgItemText(hDlg, iControl, szText);
|
|
|
|
} else {
|
|
|
|
SetWindowText(hDlg, szText);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
HdwWizPropagateMessage(
|
|
HWND hWnd,
|
|
UINT uMessage,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
while ((hWnd = GetWindow(hWnd, GW_CHILD))) {
|
|
|
|
SendMessage(hWnd, uMessage, wParam, lParam);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL
|
|
Use256Color(
|
|
VOID
|
|
)
|
|
{
|
|
HDC hdc;
|
|
BOOL bRetVal= FALSE;
|
|
|
|
hdc = GetDC(NULL);
|
|
if(hdc) {
|
|
|
|
if (GetDeviceCaps(hdc, BITSPIXEL) >= 8) {
|
|
|
|
bRetVal = TRUE;
|
|
}
|
|
|
|
ReleaseDC(NULL, hdc);
|
|
}
|
|
|
|
return bRetVal;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
HPALETTE
|
|
CreateDIBPalette(
|
|
LPBITMAPINFO lpbmi,
|
|
LPINT lpiNumColors
|
|
)
|
|
{
|
|
LPBITMAPINFOHEADER lpbi;
|
|
LPLOGPALETTE lpPal;
|
|
HANDLE hLogPal;
|
|
HPALETTE hPal = NULL;
|
|
int i;
|
|
|
|
lpbi = (LPBITMAPINFOHEADER)lpbmi;
|
|
|
|
if (lpbi->biBitCount <= 8) {
|
|
|
|
*lpiNumColors = (1 << lpbi->biBitCount);
|
|
} else {
|
|
|
|
*lpiNumColors = 0; // No palette needed for 24 BPP DIB
|
|
}
|
|
|
|
if (*lpiNumColors) {
|
|
|
|
hLogPal = GlobalAlloc(GHND,
|
|
sizeof (LOGPALETTE) +
|
|
sizeof (PALETTEENTRY) * (*lpiNumColors));
|
|
|
|
if (hLogPal) {
|
|
|
|
lpPal = (LPLOGPALETTE) GlobalLock (hLogPal);
|
|
|
|
if (lpPal) {
|
|
|
|
lpPal->palVersion = 0x300;
|
|
lpPal->palNumEntries = (unsigned short)(*lpiNumColors);
|
|
|
|
for (i = 0; i < *lpiNumColors; i++)
|
|
{
|
|
lpPal->palPalEntry[i].peRed = lpbmi->bmiColors[i].rgbRed;
|
|
lpPal->palPalEntry[i].peGreen = lpbmi->bmiColors[i].rgbGreen;
|
|
lpPal->palPalEntry[i].peBlue = lpbmi->bmiColors[i].rgbBlue;
|
|
lpPal->palPalEntry[i].peFlags = 0;
|
|
}
|
|
|
|
hPal = CreatePalette (lpPal);
|
|
GlobalUnlock (hLogPal);
|
|
GlobalFree (hLogPal);
|
|
}
|
|
}
|
|
}
|
|
|
|
return hPal;
|
|
}
|
|
|
|
|
|
BOOL
|
|
LoadBitmapAndPalette(
|
|
HINSTANCE hInstance,
|
|
LPCTSTR pszResource,
|
|
PRESOURCEBITMAP ResourceBitmap
|
|
)
|
|
{
|
|
HBITMAP hBitmap = NULL;
|
|
HPALETTE hPalette = NULL;
|
|
LPBITMAPINFOHEADER lpbi;
|
|
|
|
HDC hdc;
|
|
HRSRC hRsrc;
|
|
HGLOBAL hGlobal;
|
|
|
|
int iNumColors;
|
|
|
|
hRsrc = FindResource(hInstance, pszResource, RT_BITMAP);
|
|
if (hRsrc) {
|
|
|
|
hGlobal = LoadResource(hInstance, hRsrc);
|
|
|
|
if (hGlobal) {
|
|
|
|
lpbi = (LPBITMAPINFOHEADER)LockResource(hGlobal);
|
|
|
|
if (lpbi) {
|
|
|
|
hdc = GetDC(NULL);
|
|
|
|
hPalette = CreateDIBPalette ((LPBITMAPINFO)lpbi, &iNumColors);
|
|
|
|
if (hPalette) {
|
|
|
|
SelectPalette(hdc, hPalette, TRUE);
|
|
RealizePalette(hdc);
|
|
}
|
|
|
|
hBitmap = CreateDIBitmap(hdc,
|
|
(LPBITMAPINFOHEADER)lpbi,
|
|
(LONG)CBM_INIT,
|
|
(LPSTR)lpbi + lpbi->biSize + iNumColors * sizeof(RGBQUAD),
|
|
(LPBITMAPINFO)lpbi,
|
|
DIB_RGB_COLORS
|
|
);
|
|
|
|
UnlockResource(hGlobal);
|
|
}
|
|
|
|
FreeResource(hGlobal);
|
|
}
|
|
}
|
|
|
|
if (!hBitmap || !hPalette) {
|
|
|
|
if (hBitmap)
|
|
DeleteObject(hBitmap);
|
|
|
|
if (hPalette)
|
|
DeleteObject(hPalette);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
ResourceBitmap->hBitmap = hBitmap;
|
|
ResourceBitmap->hPalette = hPalette;
|
|
GetObject(hBitmap, sizeof(ResourceBitmap->Bitmap), &ResourceBitmap->Bitmap);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
void
|
|
HideWindowByMove(
|
|
HWND hDlg
|
|
)
|
|
{
|
|
RECT rect;
|
|
GetWindowRect(hDlg, &rect);
|
|
|
|
MoveWindow(hDlg,
|
|
0,
|
|
-(rect.bottom - rect.top),
|
|
rect.right - rect.left,
|
|
rect.bottom - rect.top,
|
|
FALSE
|
|
);
|
|
}
|
|
|
|
|
|
|
|
|
|
LONG
|
|
HdwBuildClassInfoList(
|
|
PHARDWAREWIZ HardwareWiz,
|
|
DWORD ClassListFlags,
|
|
PTCHAR MachineName
|
|
)
|
|
{
|
|
LONG Error;
|
|
|
|
while (!SetupDiBuildClassInfoListEx(ClassListFlags,
|
|
HardwareWiz->ClassGuidList,
|
|
HardwareWiz->ClassGuidSize,
|
|
&HardwareWiz->ClassGuidNum,
|
|
MachineName,
|
|
NULL
|
|
)) {
|
|
|
|
Error = GetLastError();
|
|
|
|
if (HardwareWiz->ClassGuidList) {
|
|
|
|
LocalFree(HardwareWiz->ClassGuidList);
|
|
HardwareWiz->ClassGuidList = NULL;
|
|
}
|
|
|
|
if (Error == ERROR_INSUFFICIENT_BUFFER &&
|
|
HardwareWiz->ClassGuidNum > HardwareWiz->ClassGuidSize) {
|
|
|
|
HardwareWiz->ClassGuidList = LocalAlloc(LPTR, HardwareWiz->ClassGuidNum*sizeof(GUID));
|
|
|
|
if (!HardwareWiz->ClassGuidList) {
|
|
|
|
HardwareWiz->ClassGuidSize = 0;
|
|
HardwareWiz->ClassGuidNum = 0;
|
|
return ERROR_NOT_ENOUGH_MEMORY;
|
|
}
|
|
|
|
HardwareWiz->ClassGuidSize = HardwareWiz->ClassGuidNum;
|
|
|
|
} else {
|
|
|
|
if (HardwareWiz->ClassGuidList) {
|
|
|
|
LocalFree(HardwareWiz->ClassGuidList);
|
|
}
|
|
|
|
HardwareWiz->ClassGuidSize = 0;
|
|
HardwareWiz->ClassGuidNum = 0;
|
|
return Error;
|
|
}
|
|
}
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
int
|
|
HdwMessageBox(
|
|
HWND hWnd,
|
|
LPTSTR szIdText,
|
|
LPTSTR szIdCaption,
|
|
UINT Type
|
|
)
|
|
{
|
|
TCHAR szText[MAX_PATH];
|
|
TCHAR szCaption[MAX_PATH];
|
|
|
|
if (!HIWORD(szIdText)) {
|
|
*szText = TEXT('\0');
|
|
LoadString(hHdwWiz, LOWORD(szIdText), szText, MAX_PATH);
|
|
szIdText = szText;
|
|
}
|
|
|
|
if (!HIWORD(szIdCaption)) {
|
|
*szCaption = TEXT('\0');
|
|
LoadString(hHdwWiz, LOWORD(szIdCaption), szCaption, MAX_PATH);
|
|
szIdCaption = szCaption;
|
|
}
|
|
|
|
return MessageBox(hWnd, szIdText, szIdCaption, Type);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
LONG
|
|
HdwUnhandledExceptionFilter(
|
|
struct _EXCEPTION_POINTERS *ExceptionPointers
|
|
)
|
|
{
|
|
LONG lRet;
|
|
BOOL BeingDebugged;
|
|
|
|
lRet = UnhandledExceptionFilter(ExceptionPointers);
|
|
|
|
BeingDebugged = IsDebuggerPresent();
|
|
|
|
//
|
|
// Normal code path is to handle the exception.
|
|
// However, if a debugger is present, and the system's unhandled
|
|
// exception filter returns continue search, we let it go
|
|
// thru to allow the debugger a chance at it.
|
|
//
|
|
|
|
if (lRet == EXCEPTION_CONTINUE_SEARCH && !BeingDebugged) {
|
|
lRet = EXCEPTION_EXECUTE_HANDLER;
|
|
}
|
|
|
|
return lRet;
|
|
}
|
|
|
|
BOOL
|
|
NoPrivilegeWarning(
|
|
HWND hWnd
|
|
)
|
|
/*++
|
|
|
|
This function checks to see if the user has SE_LOAD_DRIVER_NAME privileges
|
|
which means they can install and load new kernel mode drivers.
|
|
|
|
If the user does NOT have this privilege then a warning is displayed telling
|
|
them that they have insufficient privileges to install hardware on this machine.
|
|
|
|
Arguments
|
|
|
|
hWnd - Parent window handle
|
|
|
|
Return Value:
|
|
TRUE if the user does NOT have SE_LOAD_DRIVER_NAME privileges and
|
|
FALSE if the user does have this privilege
|
|
|
|
--*/
|
|
{
|
|
TCHAR szMsg[MAX_PATH];
|
|
TCHAR szCaption[MAX_PATH];
|
|
|
|
if (!pSetupDoesUserHavePrivilege((PCTSTR)SE_LOAD_DRIVER_NAME)) {
|
|
|
|
if (LoadString(hHdwWiz,
|
|
IDS_HDWUNINSTALL_NOPRIVILEGE,
|
|
szMsg,
|
|
MAX_PATH)
|
|
&&
|
|
LoadString(hHdwWiz,
|
|
IDS_HDWWIZNAME,
|
|
szCaption,
|
|
MAX_PATH))
|
|
{
|
|
MessageBox(hWnd, szMsg, szCaption, MB_OK | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
VOID
|
|
_OnSysColorChange(
|
|
HWND hWnd,
|
|
WPARAM wParam,
|
|
LPARAM lParam
|
|
)
|
|
{
|
|
|
|
HWND hChildWnd;
|
|
|
|
hChildWnd = GetWindow(hWnd, GW_CHILD);
|
|
while (hChildWnd != NULL) {
|
|
SendMessage(hChildWnd, WM_SYSCOLORCHANGE, wParam, lParam);
|
|
hChildWnd = GetWindow(hChildWnd, GW_HWNDNEXT);
|
|
}
|
|
|
|
}
|
|
|
|
void
|
|
LoadText(
|
|
PTCHAR szText,
|
|
int SizeText,
|
|
int nStartString,
|
|
int nEndString
|
|
)
|
|
{
|
|
int iX;
|
|
|
|
for (iX = nStartString; iX<= nEndString; iX++) {
|
|
|
|
LoadString(hHdwWiz,
|
|
iX,
|
|
szText + lstrlen(szText),
|
|
SizeText/sizeof(TCHAR) - lstrlen(szText)
|
|
);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/* InstallFailedWarning
|
|
*
|
|
* Displays device install failed warning in a message box. For use
|
|
* when installation fails.
|
|
*
|
|
*/
|
|
void
|
|
InstallFailedWarning(
|
|
HWND hDlg,
|
|
PHARDWAREWIZ HardwareWiz
|
|
)
|
|
{
|
|
int len;
|
|
TCHAR szMsg[MAX_MESSAGE_STRING];
|
|
TCHAR szTitle[MAX_MESSAGE_TITLE];
|
|
PTCHAR ErrorMsg;
|
|
|
|
LoadString(hHdwWiz,
|
|
IDS_ADDNEWDEVICE,
|
|
szTitle,
|
|
sizeof(szTitle)/sizeof(TCHAR)
|
|
);
|
|
|
|
if ((len = LoadString(hHdwWiz, IDS_HDW_ERRORFIN1, szMsg, sizeof(szMsg)/sizeof(TCHAR)))) {
|
|
|
|
LoadString(hHdwWiz, IDS_HDW_ERRORFIN2, szMsg+len, sizeof(szMsg)/sizeof(TCHAR)-len);
|
|
}
|
|
|
|
if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
NULL,
|
|
HRESULT_FROM_SETUPAPI(HardwareWiz->LastError),
|
|
0,
|
|
(LPTSTR)&ErrorMsg,
|
|
0,
|
|
NULL
|
|
))
|
|
{
|
|
lstrcat(szMsg, TEXT("\n\n"));
|
|
|
|
if ((lstrlen(szMsg) + lstrlen(ErrorMsg)) < SIZECHARS(szMsg)) {
|
|
|
|
lstrcat(szMsg, ErrorMsg);
|
|
}
|
|
|
|
LocalFree(ErrorMsg);
|
|
}
|
|
|
|
MessageBox(hDlg, szMsg, szTitle, MB_OK | MB_TASKMODAL | MB_ICONEXCLAMATION);
|
|
}
|
|
|
|
|
|
void
|
|
SetDriverDescription(
|
|
HWND hDlg,
|
|
int iControl,
|
|
PHARDWAREWIZ HardwareWiz
|
|
)
|
|
{
|
|
CONFIGRET ConfigRet;
|
|
ULONG ulSize;
|
|
PTCHAR FriendlyName;
|
|
PTCHAR Location;
|
|
SP_DRVINFO_DATA DriverInfoData;
|
|
|
|
|
|
//
|
|
// If there is a selected driver use its driver description,
|
|
// since this is what the user is going to install.
|
|
//
|
|
|
|
DriverInfoData.cbSize = sizeof(SP_DRVINFO_DATA);
|
|
if (SetupDiGetSelectedDriver(HardwareWiz->hDeviceInfo,
|
|
&HardwareWiz->DeviceInfoData,
|
|
&DriverInfoData
|
|
)
|
|
&&
|
|
*DriverInfoData.Description) {
|
|
|
|
wcscpy(HardwareWiz->DriverDescription, DriverInfoData.Description);
|
|
SetDlgItemText(hDlg, iControl, HardwareWiz->DriverDescription);
|
|
return;
|
|
}
|
|
|
|
|
|
FriendlyName = BuildFriendlyName(HardwareWiz->DeviceInfoData.DevInst, NULL);
|
|
if (FriendlyName) {
|
|
|
|
SetDlgItemText(hDlg, iControl, FriendlyName);
|
|
LocalFree(FriendlyName);
|
|
return;
|
|
}
|
|
|
|
SetDlgItemText(hDlg, iControl, szUnknown);
|
|
|
|
return;
|
|
}
|
|
|
|
HPROPSHEETPAGE
|
|
CreateWizExtPage(
|
|
int PageResourceId,
|
|
DLGPROC pfnDlgProc,
|
|
PHARDWAREWIZ HardwareWiz
|
|
)
|
|
{
|
|
PROPSHEETPAGE psp;
|
|
|
|
memset(&psp, 0, sizeof(PROPSHEETPAGE));
|
|
psp.dwSize = sizeof(PROPSHEETPAGE);
|
|
psp.dwFlags = PSP_DEFAULT;
|
|
psp.hInstance = hHdwWiz;
|
|
psp.lParam = (LPARAM)HardwareWiz;
|
|
psp.pszTemplate = MAKEINTRESOURCE(PageResourceId);
|
|
psp.pfnDlgProc = pfnDlgProc;
|
|
|
|
return CreatePropertySheetPage(&psp);
|
|
}
|
|
|
|
BOOL
|
|
AddClassWizExtPages(
|
|
HWND hwndParentDlg,
|
|
PHARDWAREWIZ HardwareWiz,
|
|
PSP_NEWDEVICEWIZARD_DATA DeviceWizardData,
|
|
DI_FUNCTION InstallFunction
|
|
)
|
|
{
|
|
DWORD NumPages;
|
|
BOOL bRet = FALSE;
|
|
|
|
memset(DeviceWizardData, 0, sizeof(SP_NEWDEVICEWIZARD_DATA));
|
|
DeviceWizardData->ClassInstallHeader.InstallFunction = InstallFunction;
|
|
DeviceWizardData->ClassInstallHeader.cbSize = sizeof(SP_CLASSINSTALL_HEADER);
|
|
DeviceWizardData->hwndWizardDlg = hwndParentDlg;
|
|
|
|
if (SetupDiSetClassInstallParams(HardwareWiz->hDeviceInfo,
|
|
&HardwareWiz->DeviceInfoData,
|
|
&DeviceWizardData->ClassInstallHeader,
|
|
sizeof(SP_NEWDEVICEWIZARD_DATA)
|
|
)
|
|
&&
|
|
|
|
(SetupDiCallClassInstaller(InstallFunction,
|
|
HardwareWiz->hDeviceInfo,
|
|
&HardwareWiz->DeviceInfoData
|
|
)
|
|
|
|
||
|
|
|
|
(ERROR_DI_DO_DEFAULT == GetLastError()))
|
|
|
|
&&
|
|
SetupDiGetClassInstallParams(HardwareWiz->hDeviceInfo,
|
|
&HardwareWiz->DeviceInfoData,
|
|
&DeviceWizardData->ClassInstallHeader,
|
|
sizeof(SP_NEWDEVICEWIZARD_DATA),
|
|
NULL
|
|
)
|
|
&&
|
|
DeviceWizardData->NumDynamicPages)
|
|
{
|
|
NumPages = 0;
|
|
while (NumPages < DeviceWizardData->NumDynamicPages) {
|
|
|
|
PropSheet_AddPage(hwndParentDlg, DeviceWizardData->DynamicPages[NumPages++]);
|
|
}
|
|
|
|
bRet = TRUE;
|
|
}
|
|
|
|
//
|
|
// Clear the class install parameters.
|
|
//
|
|
|
|
SetupDiSetClassInstallParams(HardwareWiz->hDeviceInfo,
|
|
&HardwareWiz->DeviceInfoData,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void
|
|
RemoveClassWizExtPages(
|
|
HWND hwndParentDlg,
|
|
PSP_NEWDEVICEWIZARD_DATA DeviceWizardData
|
|
)
|
|
{
|
|
DWORD NumPages;
|
|
|
|
NumPages = DeviceWizardData->NumDynamicPages;
|
|
while (NumPages--) {
|
|
|
|
PropSheet_RemovePage(hwndParentDlg,
|
|
(WPARAM)-1,
|
|
DeviceWizardData->DynamicPages[NumPages]
|
|
);
|
|
}
|
|
|
|
memset(DeviceWizardData, 0, sizeof(SP_NEWDEVICEWIZARD_DATA));
|
|
|
|
return;
|
|
}
|
|
|
|
BOOL
|
|
IsDeviceHidden(
|
|
PHARDWAREWIZ HardwareWiz,
|
|
PSP_DEVINFO_DATA DeviceInfoData
|
|
)
|
|
{
|
|
BOOL bHidden = FALSE;
|
|
ULONG DevNodeStatus, DevNodeProblem;
|
|
HKEY hKeyClass;
|
|
|
|
//
|
|
// If the DN_NO_SHOW_IN_DM status bit is set
|
|
// then we should hide this device.
|
|
//
|
|
if ((CM_Get_DevNode_Status(&DevNodeStatus,
|
|
&DevNodeProblem,
|
|
DeviceInfoData->DevInst,
|
|
0) == CR_SUCCESS) &&
|
|
(DevNodeStatus & DN_NO_SHOW_IN_DM)) {
|
|
|
|
bHidden = TRUE;
|
|
goto HiddenDone;
|
|
}
|
|
|
|
//
|
|
// If the devices class has the NoDisplayClass value then
|
|
// don't display this device.
|
|
//
|
|
if (hKeyClass = SetupDiOpenClassRegKeyEx(&DeviceInfoData->ClassGuid,
|
|
KEY_READ,
|
|
DIOCR_INSTALLER,
|
|
HardwareWiz->hMachine ? HardwareWiz->MachineName : NULL,
|
|
NULL)) {
|
|
|
|
if (RegQueryValueEx(hKeyClass, REGSTR_VAL_NODISPLAYCLASS, NULL, NULL, NULL, NULL) == ERROR_SUCCESS) {
|
|
|
|
bHidden = TRUE;
|
|
}
|
|
|
|
RegCloseKey(hKeyClass);
|
|
}
|
|
|
|
|
|
|
|
HiddenDone:
|
|
return bHidden;
|
|
}
|
|
|
|
DWORD
|
|
SetPrivilegeAttribute(
|
|
LPCTSTR PrivilegeName,
|
|
DWORD NewPrivilegeAttribute,
|
|
DWORD *OldPrivilegeAttribute
|
|
)
|
|
/*++
|
|
|
|
sets the security attributes for a given privilege.
|
|
|
|
Arguments:
|
|
|
|
PrivilegeName - Name of the privilege we are manipulating.
|
|
|
|
NewPrivilegeAttribute - The new attribute value to use.
|
|
|
|
OldPrivilegeAttribute - Pointer to receive the old privilege value. OPTIONAL
|
|
|
|
Return value:
|
|
|
|
NO_ERROR or WIN32 error.
|
|
|
|
--*/
|
|
{
|
|
LUID PrivilegeValue;
|
|
TOKEN_PRIVILEGES TokenPrivileges, OldTokenPrivileges;
|
|
DWORD ReturnLength;
|
|
HANDLE TokenHandle;
|
|
|
|
//
|
|
// First, find out the LUID Value of the privilege
|
|
//
|
|
|
|
if (!LookupPrivilegeValue(NULL, PrivilegeName, &PrivilegeValue))
|
|
{
|
|
return GetLastError();
|
|
}
|
|
|
|
//
|
|
// Get the token handle
|
|
//
|
|
if (!OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, &TokenHandle))
|
|
{
|
|
return GetLastError();
|
|
}
|
|
|
|
//
|
|
// Set up the privilege set we will need
|
|
//
|
|
|
|
TokenPrivileges.PrivilegeCount = 1;
|
|
TokenPrivileges.Privileges[0].Luid = PrivilegeValue;
|
|
TokenPrivileges.Privileges[0].Attributes = NewPrivilegeAttribute;
|
|
|
|
ReturnLength = sizeof( TOKEN_PRIVILEGES );
|
|
if (!AdjustTokenPrivileges (
|
|
TokenHandle,
|
|
FALSE,
|
|
&TokenPrivileges,
|
|
sizeof( TOKEN_PRIVILEGES ),
|
|
&OldTokenPrivileges,
|
|
&ReturnLength
|
|
))
|
|
{
|
|
CloseHandle(TokenHandle);
|
|
return GetLastError();
|
|
}
|
|
else
|
|
{
|
|
if (OldPrivilegeAttribute != NULL)
|
|
{
|
|
*OldPrivilegeAttribute = OldTokenPrivileges.Privileges[0].Attributes;
|
|
}
|
|
CloseHandle(TokenHandle);
|
|
return NO_ERROR;
|
|
}
|
|
}
|
|
|
|
BOOL
|
|
ShutdownMachine(
|
|
HWND hWnd
|
|
)
|
|
{
|
|
BOOL fOk;
|
|
DWORD dwExitWinCode = EWX_SHUTDOWN;
|
|
DWORD OldState;
|
|
DWORD dwError;
|
|
|
|
if (IsPwrShutdownAllowed()) {
|
|
dwExitWinCode |= EWX_POWEROFF;
|
|
}
|
|
|
|
dwError = SetPrivilegeAttribute(SE_SHUTDOWN_NAME, SE_PRIVILEGE_ENABLED, &OldState);
|
|
|
|
if (GetKeyState(VK_CONTROL) < 0) {
|
|
dwExitWinCode |= EWX_FORCE;
|
|
}
|
|
|
|
fOk = ExitWindowsEx(dwExitWinCode, REASON_PLANNED_FLAG | REASON_HWINSTALL);
|
|
|
|
//
|
|
// If we were able to set the privilege, then reset it.
|
|
//
|
|
if (dwError == ERROR_SUCCESS) {
|
|
SetPrivilegeAttribute(SE_SHUTDOWN_NAME, OldState, NULL);
|
|
}
|
|
else
|
|
{
|
|
//
|
|
// Otherwise, if we failed, then it must have been some
|
|
// security stuff.
|
|
//
|
|
if (!fOk)
|
|
{
|
|
TCHAR Title[MAX_PATH], Message[MAX_PATH];
|
|
|
|
if (LoadString(hHdwWiz, IDS_NO_PERMISSION_SHUTDOWN, Message, SIZECHARS(Message)) &&
|
|
LoadString(hHdwWiz, IDS_SHUTDOWN, Title, SIZECHARS(Title))) {
|
|
|
|
MessageBox(hWnd, Message, Title, MB_OK | MB_ICONSTOP);
|
|
}
|
|
}
|
|
}
|
|
|
|
return fOk;
|
|
}
|
|
|
|
int
|
|
DeviceProperties(
|
|
HWND hWnd,
|
|
HMACHINE hMachine,
|
|
LPCSTR MachineName,
|
|
DEVNODE DevNode,
|
|
ULONG Flags
|
|
)
|
|
{
|
|
TCHAR DeviceID[MAX_DEVICE_ID_LEN];
|
|
PDEVICEPROPERTIESEX pDevicePropertiesEx = NULL;
|
|
int iRet = 0;
|
|
|
|
if (!hDevMgr) {
|
|
return 0;
|
|
}
|
|
|
|
pDevicePropertiesEx = (PVOID) GetProcAddress(hDevMgr, "DevicePropertiesExW");
|
|
|
|
if (!pDevicePropertiesEx) {
|
|
return 0;
|
|
}
|
|
|
|
if (CM_Get_Device_ID_Ex(DevNode,
|
|
DeviceID,
|
|
SIZECHARS(DeviceID),
|
|
0,
|
|
hMachine
|
|
) == CR_SUCCESS) {
|
|
|
|
iRet = pDevicePropertiesEx(hWnd,
|
|
MachineName,
|
|
(LPCSTR)DeviceID,
|
|
Flags,
|
|
FALSE);
|
|
}
|
|
|
|
return iRet;
|
|
}
|
|
|
|
#if DBG
|
|
//
|
|
// Debugging aids
|
|
//
|
|
void
|
|
Trace(
|
|
LPCTSTR format,
|
|
...
|
|
)
|
|
{
|
|
// according to wsprintf specification, the max buffer size is
|
|
// 1024
|
|
TCHAR Buffer[1024];
|
|
va_list arglist;
|
|
va_start(arglist, format);
|
|
wvsprintf(Buffer, format, arglist);
|
|
va_end(arglist);
|
|
OutputDebugString(TEXT("HDWWIZ: "));
|
|
OutputDebugString(Buffer);
|
|
OutputDebugString(TEXT("\n"));
|
|
}
|
|
#endif
|
|
|
|
|