able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/busdrv/acpi/acpienab/acpienab.cpp

956 lines
27 KiB
C++
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1998.
//
// File: acpienab.cpp
//
// Contents: Functions to enable ACPI on a machine which has had NT5
// installed in legacy mode
//
// Notes:
//
// Author: t-sdey 17 July 98
//
//----------------------------------------------------------------------------
#include <winnt32.h>
#include <devguid.h>
extern "C" {
#include <cfgmgr32.h>
#include "idchange.h"
}
#include "acpienab.h"
#include "acpirsrc.h"
// Global Variables
HINSTANCE g_hinst;
TCHAR g_ACPIENAB_INF[] = TEXT(".\\acpienab.inf"); // local directory
TCHAR g_LAYOUT_INF[] = TEXT("layout.inf"); // winnt\inf directory
TCHAR g_HAL_BACKUP[] = TEXT("hal-old.dll");
//+---------------------------------------------------------------------------
//
// Function: WinMain
//
// Purpose: Run everything
//
// Arguments: Standard WinMain arguments
//
// Author: t-sdey 27 July 98
//
// Notes:
//
int WINAPI WinMain(HINSTANCE hInstance,
HINSTANCE hPrevInstance,
LPSTR lpCmdLine,
int nCmdShow)
{
g_hinst = hInstance;
// Enable ACPI
ACPIEnable();
return TRUE;
}
// ----------------------------------------------------------------------
//
// Function: ACPIEnable
//
// Purpose: This function performs the steps necessary to enable ACPI
// and bring the system to a point where the user can log in
// after rebooting. It leaves finding "new" hardware to after
// the user has rebooted and logged in again.
//
// Arguments:
//
// Returns: S_OK if successful
// S_FALSE if unsuccessful
//
// Author: t-sdey 27 July 98
//
// Notes:
//
HRESULT ACPIEnable()
{
//
// These steps are in order from least to most crucial to the stability
// of the system, in case of errors.
//
// Step 1: Test to see if ACPI can be enabled and warn the user to close
// everything else.
// Step 2: Prepare a safe configuration in case of errors.
// Step 3: Set up keyboard and mouse for use after reboot. This involves
// removing them from the CriticalDeviceDatabase so that they will
// be reconfigured (according to the new ACPI layout) after reboot.
// The current keyboards and mice are in the CDD, but we must
// populate it with all possibilities, because their HardwareIDs
// will probably change once ACPI is enabled.
// Step 4: Add new values to the registry:
// - Add ACPI to the CriticalDeviceDatabase
// - Add keyboards and mice to the CriticalDeviceDatabase
// - Enable ACPI in the registry
// Step 5: Copy the ACPI driver.
// Step 6: Copy the new HAL.
// Step 7: Reboot.
//
//
// Step 1: Test to see if ACPI can be enabled and warn the user to close
// everything else.
//
// Make sure the user has administrative access
if (!IsAdministrator()) {
DisplayDialogBox(ACPI_STR_ERROR_DIALOG_CAPTION,
ACPI_STR_ADMIN_ACCESS_REQUIRED,
MB_OK | MB_ICONERROR);
return S_FALSE;
}
// Test to see if ACPI is supported on this architecture
SYSTEM_INFO SystemInfo; // Will be used later to determine HAL
GetSystemInfo(&SystemInfo);
if (SystemInfo.wProcessorArchitecture != PROCESSOR_ARCHITECTURE_INTEL) {
// Not supported
DisplayDialogBox(ACPI_STR_ERROR_DIALOG_CAPTION,
ACPI_STR_NOT_SUPPORTED,
MB_OK | MB_ICONERROR);
return S_FALSE;
}
// Warn the user to shut down any other programs
if (DisplayDialogBox(ACPI_STR_WARNING_DIALOG_CAPTION,
ACPI_STR_SHUTDOWN_WARNING,
MB_YESNO | MB_ICONWARNING) == IDNO) {
// The user cancelled
return S_FALSE;
}
//
// Step 2: Prepare a safe configuration in case of errors.
//
// Make a backup copy of the old HAL
// Get location of the system directory
TCHAR* szSystemDir = new TCHAR[MAX_PATH+1];
if (!szSystemDir) {
// Out of memory
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
UINT uiSysDirLen = GetSystemDirectory(szSystemDir, MAX_PATH+1);
if (uiSysDirLen == 0) {
// Some error occurred
DisplayGenericErrorAndUndoChanges();
if (szSystemDir) delete[] szSystemDir;
return S_FALSE;
}
// Assemble strings with the locations of the current and backup file
TCHAR szHal[] = TEXT("hal.dll");
TCHAR* szHalCurrent = new TCHAR[uiSysDirLen + lstrlen(szHal) + 1];
TCHAR* szHalBackup = new TCHAR[uiSysDirLen + lstrlen(g_HAL_BACKUP) + 1];
if (!szHalCurrent || !szHalBackup) {
// Out of memory
DisplayGenericErrorAndUndoChanges();
delete[] szSystemDir;
if (szHalCurrent) delete[] szHalCurrent;
if (szHalBackup) delete[] szHalBackup;
return S_FALSE;
}
_tcscpy(szHalCurrent, szSystemDir);
_tcscat(szHalCurrent, TEXT("\\"));
_tcscat(szHalCurrent, szHal);
_tcscpy(szHalBackup, szSystemDir);
_tcscat(szHalBackup, TEXT("\\"));
_tcscat(szHalBackup, g_HAL_BACKUP);
// Copy the HAL
if (CopyFile(szHalCurrent, szHalBackup, FALSE) == FALSE) {
// Error copying file
DisplayGenericErrorAndUndoChanges();
delete[] szSystemDir;
delete[] szHalCurrent;
delete[] szHalBackup;
return S_FALSE;
}
delete[] szSystemDir;
delete[] szHalCurrent;
delete[] szHalBackup;
// Make it possible to boot with the backup HAL if necessary
// Find the system partition letter
// Edit boot.ini
// -- add new NT5 boot line with "\HAL=hal-old.dll" on the end
// Temporary: tell the user to do it manually
MessageBox(NULL,
TEXT("If you want to ensure that you can recover if this process fails,\nadd a line to your boot.ini with \" /HAL=hal-old.dll\""),
TEXT("This is a temporary hack!"),
MB_ICONWARNING | MB_OK);
//
// Step 3: Set up keyboard and mouse for use after reboot. This involves
// removing them from the CriticalDeviceDatabase so that they will
// be reconfigured (according to the new ACPI layout) after reboot.
// The current keyboards and mice are in the CDD, but we must
// populate it with all possibilities, because their HardwareIDs
// will probably change once ACPI is enabled.
//
// Set up keyboard(s) for use after reboot
if (RegDeleteDeviceKey(&GUID_DEVCLASS_KEYBOARD) == FALSE) {
// Error
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
// Set up mouse (mice) for use after reboot
if (RegDeleteDeviceKey(&GUID_DEVCLASS_MOUSE) == FALSE) {
// Error
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
//
// Step 4: Add new values to the registry:
// - Add ACPI to the CriticalDeviceDatabase
// - Add keyboards and mice to the CriticalDeviceDatabase
// - Enable ACPI in the registry
//
if (InstallRegistryAndFilesUsingInf(g_ACPIENAB_INF,
TEXT("ACPI_REGISTRY.Install")) == 0) {
// Error
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
//
// Step 5: Copy the ACPI driver.
//
// Copy the ACPI driver to the system directory
if (InstallRegistryAndFilesUsingInf(g_ACPIENAB_INF,
TEXT("ACPI_DRIVER.Install")) == 0) {
// Error
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
//
// Step 6: Copy the new HAL.
//
// Determine which HAL will be needed
TCHAR szHalInstall[50];
int HAL = 0;
// Determine if it's a single or multi-processor machine
BOOL SingleProc = (SystemInfo.dwNumberOfProcessors == 1);
if (SingleProc) {
HAL += 2;
}
// Determine if it's a PIC or APIC machine
BOOL PIC = TRUE;
if (!SingleProc) { // Don't run the UsePICHal function unless we have to
PIC = FALSE;
} else {
if (UsePICHal(&PIC) == FALSE) {
// An error occurred
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
}
if (PIC) {
HAL += 1;
}
// Lookup table for HALs
switch (HAL) {
case 3: // x86 1-proc PIC
_tcscpy(szHalInstall, TEXT("INTEL_1PROC_PIC_HAL"));
break;
case 2: // x86 1-proc APIC
_tcscpy(szHalInstall, TEXT("INTEL_1PROC_APIC_HAL"));
break;
case 1: // x86 multi-proc PIC -- doesn't exist...
_tcscpy(szHalInstall, TEXT("INTEL_MULTIPROC_PIC_HAL"));
break;
case 0: // x86 multi-proc APIC
_tcscpy(szHalInstall, TEXT("INTEL_MULTIPROC_APIC_HAL"));
break;
}
_tcscat(szHalInstall, TEXT(".Install"));
// Copy the HAL to the system directory
if (InstallRegistryAndFilesUsingInf(g_ACPIENAB_INF, szHalInstall) == 0) {
// Error
DisplayGenericErrorAndUndoChanges();
return S_FALSE;
}
//
// Step 7: Reboot.
//
// Warn the user that we're going to reboot
DisplayDialogBox(ACPI_STR_REBOOT_DIALOG_CAPTION,
ACPI_STR_REBOOT_WARNING,
MB_OK);
// Get shutdown privilege by opening the process token and adjusting its
// privileges.
HANDLE hToken;
TOKEN_PRIVILEGES tkp;
if (!OpenProcessToken(GetCurrentProcess(),
TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
&hToken)) {
// Could not open process token. Tell the user to reboot manually.
DisplayDialogBox(ACPI_STR_REBOOT_DIALOG_CAPTION,
ACPI_STR_REBOOT_ERROR,
MB_OK);
return S_OK;
}
LookupPrivilegeValue(NULL,
SE_SHUTDOWN_NAME,
&tkp.Privileges[0].Luid);
tkp.PrivilegeCount = 1;
tkp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;
AdjustTokenPrivileges(hToken, FALSE, &tkp, 0, (PTOKEN_PRIVILEGES)NULL, 0);
// Reboot
if (ExitWindowsEx(EWX_REBOOT | EWX_FORCEIFHUNG, 0) == 0) {
// An error occurred. Tell the user to reboot manually.
DisplayDialogBox(ACPI_STR_REBOOT_DIALOG_CAPTION,
ACPI_STR_REBOOT_ERROR,
MB_OK);
}
return S_OK;
}
//+---------------------------------------------------------------------------
//
// Function: InstallRegistryAndFilesUsingInf
//
// Purpose: Open an INF file and perform the registry addition/deletion and
// file copy operations specified there under a given install
// section.
//
// Arguments: szInfFileName [in] Name of INF file to open
// (should be located in system inf
// directory)
// szInstallSection [in] Install section (in INF) to use
//
// Returns: TRUE if successful
// FALSE otherwise
//
// Author: t-sdey 14 Aug 98
//
// Notes:
//
BOOL InstallRegistryAndFilesUsingInf(IN LPCTSTR szInfFileName,
IN LPCTSTR szInstallSection)
{
HINF hinf;
//
// Prepare the file queue
//
// Create a file queue
HSPFILEQ FileQueue = SetupOpenFileQueue();
if(!FileQueue || (FileQueue == INVALID_HANDLE_VALUE)) {
// Error
return FALSE;
}
// Initialize the queue callback function
HWND Window = NULL;
VOID* DefaultContext = SetupInitDefaultQueueCallback(Window);
//
// Open the INF file and perform file installation
//
// Open the source INF
hinf = SetupOpenInfFile(szInfFileName, TEXT("System"), INF_STYLE_WIN4, NULL);
if (hinf == INVALID_HANDLE_VALUE) {
// Error
SetupCloseFileQueue(FileQueue);
return FALSE;
}
// Append the layout INF to get the source location for the files
if (SetupOpenAppendInfFile(g_LAYOUT_INF, hinf, NULL) == FALSE) {
// Could not open file
SetupCloseInfFile(hinf);
SetupCloseFileQueue(FileQueue);
return FALSE;
}
// Read the INF and perform the actions it dictates
if (SetupInstallFromInfSection(NULL,
hinf,
szInstallSection,
SPINST_REGISTRY | SPINST_FILES,
HKEY_LOCAL_MACHINE,
NULL, // Source root path
SP_COPY_WARNIFSKIP,
(PSP_FILE_CALLBACK)SetupDefaultQueueCallback,
DefaultContext,
NULL,
NULL) == 0) {
// Error
SetupCloseInfFile(hinf);
SetupCloseFileQueue(FileQueue);
return FALSE;
}
// Commit the file queue to make sure all queued file copies are performed
if (SetupCommitFileQueue(NULL,
FileQueue,
(PSP_FILE_CALLBACK)SetupDefaultQueueCallback,
DefaultContext) == 0) {
// Error
SetupCloseInfFile(hinf);
SetupCloseFileQueue(FileQueue);
return FALSE;
}
// Clean up
SetupCloseInfFile(hinf);
SetupCloseFileQueue(FileQueue);
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Function: RegDeleteDeviceKey
//
// Purpose: All devices described by guid are removed from the device
// tree (HKLM\SYSTEM\CurrentControlSet\Enum\Root).
// This forces them to be reconfigured on reboot.
//
// Arguments: guid [in] GUID of device class
//
// Returns: TRUE if successful.
// FALSE otherwise.
//
// Author: t-sdey 14 Aug 98
//
// Notes:
//
BOOL RegDeleteDeviceKey(IN const GUID* guid)
{
// Open the Root key under Enum with administrative access
HKEY hkey = NULL;
TCHAR szEnumRoot[] = TEXT("SYSTEM\\CurrentControlSet\\Enum\\Root");
PSECURITY_DESCRIPTOR psdOriginal = NULL;
if (DwRegOpenKeyExWithAdminAccess(HKEY_LOCAL_MACHINE,
szEnumRoot,
KEY_ALL_ACCESS,
&hkey,
&psdOriginal) != ERROR_SUCCESS) {
// Error
RegCloseKey(hkey);
return FALSE;
}
// Get the list of devices with this GUID on the system. Remove each
// of them from the device tree, so that the next time the computer boots
// it is re-detected and re-configured for the new ACPI setup.
// (Otherwise the device will be configured incorrectly.)
// Get the list of devices with this GUID on the system
HDEVINFO hdiDeviceClass = SetupDiGetClassDevs(guid, NULL, NULL, 0);
// Prepare data structures for loop
SP_DEVINFO_DATA DeviceInfoData;
DeviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA);
DWORD dwIndex = 0;
unsigned long BufferMax = 5000; // 5000 chars better be enough for the HID!
unsigned long BufferLen;
TCHAR* szHardwareID = new TCHAR[BufferMax];
if (szHardwareID == NULL) {
// Out of memory
DisplayGenericErrorAndUndoChanges();
SetupDiDestroyDeviceInfoList(hdiDeviceClass);
if (psdOriginal) delete psdOriginal;
RegCloseKey(hkey);
return FALSE;
}
// Loop for each device with this GUID
while (SetupDiEnumDeviceInfo(hdiDeviceClass, dwIndex, &DeviceInfoData)) {
// Get the Hardware ID
BufferLen = BufferMax;
if (CM_Get_DevInst_Registry_Property_Ex(DeviceInfoData.DevInst,
CM_DRP_HARDWAREID,
NULL,
szHardwareID,
&BufferLen,
0,
0) != CR_SUCCESS) {
// Error
DisplayGenericErrorAndUndoChanges();
SetupDiDestroyDeviceInfoList(hdiDeviceClass);
if (szHardwareID) delete[] szHardwareID;
if (psdOriginal) delete psdOriginal;
RegCloseKey(hkey);
return FALSE;
}
// Remove from the device tree
if (RegDeleteKeyAndSubkeys(hkey, szHardwareID, TRUE) != ERROR_SUCCESS) {
// Error
DisplayGenericErrorAndUndoChanges();
SetupDiDestroyDeviceInfoList(hdiDeviceClass);
if (szHardwareID) delete[] szHardwareID;
if (psdOriginal) delete psdOriginal;
RegCloseKey(hkey);
return FALSE;
}
dwIndex++;
}
// Reset the security on the Root key
if (psdOriginal) {
RegSetKeySecurity(hkey,
(SECURITY_INFORMATION) (DACL_SECURITY_INFORMATION),
psdOriginal);
delete psdOriginal;
}
// Clean up
SetupDiDestroyDeviceInfoList(hdiDeviceClass);
if (szHardwareID)
delete[] szHardwareID;
if (hkey)
RegCloseKey(hkey);
return TRUE;
}
//+---------------------------------------------------------------------------
//
// Function: DisplayGenericErrorAndUndoChanges
//
// Purpose: Pop up a message box with a generic error message and then
// undo as many changes as possible. Basically, used to recover
// from errors which occur before ACPI is fully enabled.
//
// Arguments:
//
// Author: t-sdey 31 July 98
//
// Notes:
//
void DisplayGenericErrorAndUndoChanges()
{
// Give a generic error message
DisplayDialogBox(ACPI_STR_ERROR_DIALOG_CAPTION,
ACPI_STR_GENERAL_ERROR_MESSAGE,
MB_OK | MB_ICONERROR);
// Remove new entries from the CriticalDeviceDatabase
InstallRegistryAndFilesUsingInf(g_ACPIENAB_INF,
TEXT("ACPI_UNDO_CHANGES.Install"));
}
//+---------------------------------------------------------------------------
//
// Function: DisplayDialogBox
//
// Purpose: Display a popup informing the user of a warning or error.
//
// Arguments: dwCaptionID [in] the ID of the caption for the window
// dwMessageID [in] the ID of the message to display
// uiBoxType [in] the type of box to use
//
// Returns: integer flag, as would be returned by MessageBox
//
// Author: t-sdey 28 July 98
//
// Notes:
//
int DisplayDialogBox(IN DWORD dwCaptionID,
IN DWORD dwMessageID,
IN UINT uiBoxType)
{
// Prepare the strings
TCHAR szCaption[512];
TCHAR szMessage[5000];
if(!LoadString(g_hinst, dwCaptionID, szCaption, 512)) {
szCaption[0] = 0;
}
if(!LoadString(g_hinst, dwMessageID, szMessage, 5000)) {
szMessage[0] = 0;
}
// Create the dialog box
return (MessageBox(NULL, szMessage, szCaption, uiBoxType));
}
//+---------------------------------------------------------------------------
//
// Function: RegDeleteKeyAndSubkeys
//
// Purpose: (Recursively) Remove a registry key and all of its subkeys
//
// Arguments: hKey [in] Handle to an open registry key
// lpszSubKey [in] Name of a subkey to be deleted along with all
// of its subkeys
// UseAdminAccess [in] Flag to indicate whether or not to try to
// use administrative access
//
// Returns: ERROR_SUCCESS if entire subtree was successfully deleted.
// ERROR_ACCESS_DENIED if given subkey could not be deleted.
//
// Author: t-sdey 15 July 98
//
// Notes: Modified from regedit.
// This specifically does not attempt to deal rationally with the
// case where the caller may not have access to some of the subkeys
// of the key to be deleted. In this case, all the subkeys which
// the caller can delete will be deleted, but the api will still
// return ERROR_ACCESS_DENIED.
//
LONG RegDeleteKeyAndSubkeys(IN HKEY hKey,
IN LPTSTR lpszSubKey,
IN BOOL UseAdminAccess)
{
DWORD i;
HKEY Key;
LONG Status;
DWORD dwStatus;
DWORD ClassLength=0;
DWORD SubKeys;
DWORD MaxSubKey;
DWORD MaxClass;
DWORD Values;
DWORD MaxValueName;
DWORD MaxValueData;
DWORD SecurityLength;
FILETIME LastWriteTime;
LPTSTR NameBuffer;
PSECURITY_DESCRIPTOR psdOriginal = NULL; // used to remember security settings
//
// First open the given key so we can enumerate its subkeys
//
if (UseAdminAccess) {
dwStatus = DwRegOpenKeyExWithAdminAccess(hKey,
lpszSubKey,
KEY_ALL_ACCESS,
&Key,
&psdOriginal);
if (dwStatus == ERROR_SUCCESS) {
Status = ERROR_SUCCESS;
} else {
Status = !(ERROR_SUCCESS); // It just has to be something else
}
} else {
Status = RegOpenKeyEx(hKey,
lpszSubKey,
0,
KEY_ENUMERATE_SUB_KEYS | KEY_QUERY_VALUE,
&Key);
}
if (Status != ERROR_SUCCESS) {
//
// possibly we have delete access, but not enumerate/query.
// So go ahead and try the delete call, but don't worry about
// any subkeys. If we have any, the delete will fail anyway.
//
Status = RegDeleteKey(hKey, lpszSubKey);
if (psdOriginal) {
// Make sure to reset the subkey security -- probably a paranoid check
RegSetKeySecurity(Key,
(SECURITY_INFORMATION) (DACL_SECURITY_INFORMATION),
psdOriginal);
free(psdOriginal);
}
return(Status);
}
//
// Use RegQueryInfoKey to determine how big to allocate the buffer
// for the subkey names.
//
Status = RegQueryInfoKey(Key,
NULL,
&ClassLength,
0,
&SubKeys,
&MaxSubKey,
&MaxClass,
&Values,
&MaxValueName,
&MaxValueData,
&SecurityLength,
&LastWriteTime);
if ((Status != ERROR_SUCCESS) &&
(Status != ERROR_MORE_DATA) &&
(Status != ERROR_INSUFFICIENT_BUFFER)) {
// Make sure to reset the subkey security
if (psdOriginal) {
RegSetKeySecurity(Key,
(SECURITY_INFORMATION) (DACL_SECURITY_INFORMATION),
psdOriginal);
free(psdOriginal);
}
RegCloseKey(Key);
return(Status);
}
NameBuffer = (LPTSTR) LocalAlloc(LPTR, (MaxSubKey + 1)*sizeof(TCHAR));
if (NameBuffer == NULL) {
// Make sure to reset the subkey security
if (psdOriginal) {
RegSetKeySecurity(Key,
(SECURITY_INFORMATION) (DACL_SECURITY_INFORMATION),
psdOriginal);
free(psdOriginal);
}
RegCloseKey(Key);
return(ERROR_NOT_ENOUGH_MEMORY);
}
//
// Enumerate subkeys and apply ourselves to each one.
//
i=0;
do {
Status = RegEnumKey(Key, i, NameBuffer, MaxSubKey+1);
if (Status == ERROR_SUCCESS) {
Status = RegDeleteKeyAndSubkeys(Key, NameBuffer, UseAdminAccess);
}
if (Status != ERROR_SUCCESS) {
//
// Failed to delete the key at the specified index. Increment
// the index and keep going. We could probably bail out here,
// since the api is going to fail, but we might as well keep
// going and delete everything we can.
//
++i;
}
} while ((Status != ERROR_NO_MORE_ITEMS) && (i < SubKeys));
LocalFree((HLOCAL) NameBuffer);
RegCloseKey(Key);
// Delete the key
Status = RegDeleteKey(hKey, lpszSubKey);
if (psdOriginal)
free(psdOriginal);
return (Status);
}
//+---------------------------------------------------------------------------
//
// Function: IsAdministrator
//
// Purpose: Determine whether or not the current user has administrative
// access to the system.
//
// Arguments:
//
// Returns: TRUE if the current user has administrative access
// FALSE otherwise
//
// Author: t-sdey 17 Aug 98
//
// Notes: Copied from \nt\private\tapi\tomahawk\admin\setup\admin.c
//
BOOL IsAdministrator()
{
PTOKEN_GROUPS ptgGroups;
DWORD dwSize, dwBufferSize;
HANDLE hThread;
HANDLE hAccessToken;
PSID psidAdministrators;
SID_IDENTIFIER_AUTHORITY siaNtAuthority = SECURITY_NT_AUTHORITY;
UINT x;
BOOL bResult = FALSE;
dwSize = 1000;
ptgGroups = (PTOKEN_GROUPS)GlobalAlloc(GPTR, dwSize);
hThread = GetCurrentProcess();
if (!(OpenProcessToken(hThread,
TOKEN_READ,
&hAccessToken))) {
CloseHandle(hThread);
return FALSE;
}
dwBufferSize = 0;
while (TRUE)
{
if (GetTokenInformation(hAccessToken,
TokenGroups,
(LPVOID)ptgGroups,
dwSize,
&dwBufferSize)) {
break;
}
if (dwBufferSize > dwSize) {
GlobalFree(ptgGroups);
ptgGroups = (PTOKEN_GROUPS)GlobalAlloc(GPTR, dwBufferSize);
dwSize = dwBufferSize;
} else {
CloseHandle(hThread);
CloseHandle(hAccessToken);
return FALSE;
}
}
if ( !(AllocateAndInitializeSid(&siaNtAuthority,
2,
SECURITY_BUILTIN_DOMAIN_RID,
DOMAIN_ALIAS_RID_ADMINS,
0, 0, 0, 0, 0, 0,
&psidAdministrators))) {
CloseHandle(hThread);
CloseHandle(hAccessToken);
GlobalFree( ptgGroups );
return FALSE;
}
for (x = 0; x < ptgGroups->GroupCount; x++) {
if (EqualSid(psidAdministrators, ptgGroups->Groups[x].Sid)) {
bResult = TRUE;
break;
}
}
FreeSid(psidAdministrators);
CloseHandle(hAccessToken);
CloseHandle(hThread);
GlobalFree(ptgGroups);
return bResult;
}
//+---------------------------------------------------------------------------
//
// Function: UsePICHal
//
// Purpose: Determine whether this is a PIC machine or not (not=APIC).
//
// Arguments: pPIC [out] A flag saying whether or not the machine is a PIC
// machine. If it is (and there are no errors) then
// pPIC will be set to TRUE. If it is an APIC machine
// pPIC will be FALSE.
//
// Returns: TRUE if test was successful
// FALSE if an error occurred
//
// Author: t-sdey 20 Aug 98
//
// Notes:
//
BOOL UsePICHal(IN BOOL* PIC)
{
*PIC = TRUE;
// Find out which HAL was installed during setup by looking at
// winnt\repair\setup.log.
//
// Determine the location of the setup log
//
// Determine the location of the windows directory
TCHAR* szLogPath = new TCHAR[MAX_PATH+1];
if (!szLogPath) {
// Out of memory
return FALSE;
}
if (GetWindowsDirectory(szLogPath, MAX_PATH+1) == 0) {
// Some error occurred
if (szLogPath) delete[] szLogPath;
return FALSE;
}
// Complete the log path
_tcscat(szLogPath, TEXT("\\repair\\setup.log"));
//
// Get the string describing the HAL that was used in setup
//
TCHAR szSetupHal[100];
int numchars= GetPrivateProfileString(TEXT("Files.WinNt"),
TEXT("\\WINNT\\system32\\hal.dll"),
TEXT("DEFAULT"),
szSetupHal,
100,
szLogPath);
if (numchars == 0) {
// Could not get string
if (szLogPath) delete[] szLogPath;
return FALSE;
}
//
// Determine if the APIC HAL was installed
//
// Test to see if the string is "halapic.dll"
TCHAR szApicHal[] = TEXT("halapic.dll");
szSetupHal[lstrlen(szApicHal)] = 0; // make sure it's null-terminated
if (_tcsstr(szSetupHal, szApicHal) != NULL) {
// They match... It's an APIC HAL
*PIC = FALSE;
}
delete[] szLogPath;
return TRUE;
}
Reference in a new issue Copy permalink