able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/syssetup/misc.c

1935 lines
48 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
#include "setupp.h"
#pragma hdrstop
//
// Safe boot strings
//
#define SAFEBOOT_OPTION_KEY TEXT("System\\CurrentControlSet\\Control\\SafeBoot\\Option")
#define OPTION_VALUE TEXT("OptionValue")
VOID
SetUpProductTypeName(
OUT PWSTR ProductTypeString,
IN UINT BufferSizeChars
)
{
switch(ProductType) {
case PRODUCT_WORKSTATION:
lstrcpyn(ProductTypeString,L"WinNT",BufferSizeChars);
break;
case PRODUCT_SERVER_PRIMARY:
lstrcpyn(ProductTypeString,L"LanmanNT",BufferSizeChars);
break;
case PRODUCT_SERVER_STANDALONE:
lstrcpyn(ProductTypeString,L"ServerNT",BufferSizeChars);
break;
default:
LoadString(MyModuleHandle,IDS_UNKNOWN,ProductTypeString,BufferSizeChars);
break;
}
}
HMODULE
MyLoadLibraryWithSignatureCheck(
IN PWSTR ModuleName
)
/*++
Routine Description:
verifies the signature for a dll and if it's ok, then load the dll
Arguments:
ModuleName - filename to be loaded.
Return Value:
an HMODULE on success, else NULL
--*/
{
WCHAR FullModuleName[MAX_PATH];
PWSTR p;
DWORD error;
if (!GetFullPathName(ModuleName,MAX_PATH,FullModuleName,&p)) {
//
// couldn't get full path to file
//
SetupDebugPrint1( L"Setup: MyLoadLibraryWithSignatureCheck failed GetFullPathName, le = %d\n",
GetLastError() );
return NULL;
}
error = pSetupVerifyFile(
NULL,
NULL,
NULL,
0,
pSetupGetFileTitle(FullModuleName),
FullModuleName,
NULL,
NULL,
FALSE,
NULL,
NULL,
NULL );
if (NO_ERROR != error) {
//
// signing problem
//
SetupDebugPrint1( L"Setup: MyLoadLibraryWithSignatureCheck failed pSetupVerifyFile, le = %x\n",
error );
SetLastError(error);
return NULL;
}
return (LoadLibrary(FullModuleName));
}
UINT
MyGetDriveType(
IN WCHAR Drive
)
{
WCHAR DriveNameNt[] = L"\\\\.\\?:";
WCHAR DriveName[] = L"?:\\";
HANDLE hDisk;
BOOL b;
UINT rc;
DWORD DataSize;
DISK_GEOMETRY MediaInfo;
//
// First, get the win32 drive type. If it tells us DRIVE_REMOVABLE,
// then we need to see whether it's a floppy or hard disk. Otherwise
// just believe the api.
//
DriveName[0] = Drive;
if((rc = GetDriveType(DriveName)) == DRIVE_REMOVABLE) {
DriveNameNt[4] = Drive;
hDisk = CreateFile(
DriveNameNt,
FILE_READ_ATTRIBUTES,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL
);
if(hDisk != INVALID_HANDLE_VALUE) {
b = DeviceIoControl(
hDisk,
IOCTL_DISK_GET_DRIVE_GEOMETRY,
NULL,
0,
&MediaInfo,
sizeof(MediaInfo),
&DataSize,
NULL
);
//
// It's really a hard disk if the media type is removable.
//
if(b && (MediaInfo.MediaType == RemovableMedia)) {
rc = DRIVE_FIXED;
}
CloseHandle(hDisk);
}
}
return(rc);
}
BOOL
GetPartitionInfo(
IN WCHAR Drive,
OUT PPARTITION_INFORMATION PartitionInfo
)
{
WCHAR DriveName[] = L"\\\\.\\?:";
HANDLE hDisk;
BOOL b;
DWORD DataSize;
DriveName[4] = Drive;
hDisk = CreateFile(
DriveName,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL
);
if(hDisk == INVALID_HANDLE_VALUE) {
return(FALSE);
}
b = DeviceIoControl(
hDisk,
IOCTL_DISK_GET_PARTITION_INFO,
NULL,
0,
PartitionInfo,
sizeof(PARTITION_INFORMATION),
&DataSize,
NULL
);
CloseHandle(hDisk);
return(b);
}
BOOL
IsErrorLogEmpty (
VOID
)
/*++
Routine Description:
Checks to see if the error log is empty.
Arguments:
None.
Returns:
TRUE if the error log size is zero.
--*/
{
HANDLE ErrorLog;
WCHAR LogName[MAX_PATH];
DWORD Size = 0;
if( GetWindowsDirectory (LogName, MAX_PATH) ) {
pSetupConcatenatePaths (LogName, SETUPLOG_ERROR_FILENAME, MAX_PATH, NULL);
ErrorLog = CreateFile (
LogName,
GENERIC_READ,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL
);
if (ErrorLog != INVALID_HANDLE_VALUE) {
Size = GetFileSize (ErrorLog, NULL);
CloseHandle (ErrorLog);
}
}
return Size == 0;
}
VOID
PumpMessageQueue(
VOID
)
{
MSG msg;
while(PeekMessage(&msg,NULL,0,0,PM_REMOVE)) {
DispatchMessage(&msg);
}
}
PVOID
InitSysSetupQueueCallbackEx(
IN HWND OwnerWindow,
IN HWND AlternateProgressWindow, OPTIONAL
IN UINT ProgressMessage,
IN DWORD Reserved1,
IN PVOID Reserved2
)
{
PSYSSETUP_QUEUE_CONTEXT SysSetupContext;
SysSetupContext = MyMalloc(sizeof(SYSSETUP_QUEUE_CONTEXT));
if(SysSetupContext) {
SysSetupContext->Skipped = FALSE;
SysSetupContext->DefaultContext = SetupInitDefaultQueueCallbackEx(
OwnerWindow,
AlternateProgressWindow,
ProgressMessage,
Reserved1,
Reserved2
);
}
return SysSetupContext;
}
PVOID
InitSysSetupQueueCallback(
IN HWND OwnerWindow
)
{
return(InitSysSetupQueueCallbackEx(OwnerWindow,NULL,0,0,NULL));
}
VOID
TermSysSetupQueueCallback(
IN PVOID SysSetupContext
)
{
PSYSSETUP_QUEUE_CONTEXT Context = SysSetupContext;
try {
if(Context->DefaultContext) {
SetupTermDefaultQueueCallback(Context->DefaultContext);
}
MyFree(Context);
} except(EXCEPTION_EXECUTE_HANDLER) {
;
}
}
#if 0
UINT
VersionCheckQueueCallback(
IN PVOID Context,
IN UINT Notification,
IN UINT_PTR Param1,
IN UINT_PTR Param2
)
{
PFILEPATHS FilePaths = (PFILEPATHS)Param1;
//
// If we're being notified that a version mismatch was found,
// indicate that the file shouldn't be copied. Otherwise,
// pass the notification on.
//
if((Notification & (SPFILENOTIFY_LANGMISMATCH |
SPFILENOTIFY_TARGETNEWER |
SPFILENOTIFY_TARGETEXISTS)) != 0) {
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
, // MSG_LOG_VERSION_MISMATCH, This message is no longer appropriate.
FilePaths->Source,
FilePaths->Target,
NULL,NULL);
return(0);
}
//
// Want default processing.
//
return(SysSetupQueueCallback(Context,Notification,Param1,Param2));
}
#endif
UINT
SysSetupQueueCallback(
IN PVOID Context,
IN UINT Notification,
IN UINT_PTR Param1,
IN UINT_PTR Param2
)
{
UINT Status;
PSYSSETUP_QUEUE_CONTEXT SysSetupContext = Context;
PFILEPATHS FilePaths = (PFILEPATHS)Param1;
PSOURCE_MEDIA SourceMedia = (PSOURCE_MEDIA)Param1;
REGISTRATION_CONTEXT RegistrationContext;
//
// If we're being notified that a file is missing and we're supposed
// to skip missing files, then return skip. Otherwise pass it on
// to the default callback routine.
//
if(( (Notification == SPFILENOTIFY_COPYERROR) || (Notification == SPFILENOTIFY_NEEDMEDIA) ) && SkipMissingFiles) {
if((FilePaths->Win32Error == ERROR_FILE_NOT_FOUND)
|| (FilePaths->Win32Error == ERROR_PATH_NOT_FOUND)) {
if(Notification == SPFILENOTIFY_COPYERROR)
SetuplogError(
LogSevWarning,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_COPY_ERROR,
FilePaths->Source,
FilePaths->Target, NULL,
SETUPLOG_USE_MESSAGEID,
FilePaths->Win32Error,
NULL,NULL);
else
SetuplogError(
LogSevError,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_NEEDMEDIA_SKIP,
SourceMedia->SourceFile,
SourceMedia->SourcePath,
NULL,NULL);
return(FILEOP_SKIP);
}
}
if ((Notification == SPFILENOTIFY_COPYERROR
|| Notification == SPFILENOTIFY_RENAMEERROR
|| Notification == SPFILENOTIFY_DELETEERROR) &&
(FilePaths->Win32Error == ERROR_DIRECTORY)) {
WCHAR Buffer[MAX_PATH];
PWSTR p;
//
// The target directory has been converted into a file by autochk.
// just delete it -- we might be in trouble if the target directory was
// really important, but it's worth trying
//
wcscpy( Buffer,FilePaths->Target);
p = wcsrchr(Buffer,L'\\');
if (p) {
*p = (WCHAR)NULL;
}
if (FileExists(Buffer,NULL)) {
DeleteFile( Buffer );
SetupDebugPrint1(L"autochk turned directory %s into file, delete file and retry\n", Buffer);
return(FILEOP_RETRY);
}
}
//
// If we're being notified that a version mismatch was found,
// silently overwrite the file. Otherwise, pass the notification on.
//
if((Notification & (SPFILENOTIFY_LANGMISMATCH |
SPFILENOTIFY_TARGETNEWER |
SPFILENOTIFY_TARGETEXISTS)) != 0) {
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_VERSION_MISMATCH,
FilePaths->Source,
FilePaths->Target,
NULL,NULL);
return(FILEOP_DOIT);
}
//
// Use default processing, then check for errors.
//
Status = SetupDefaultQueueCallback(
SysSetupContext->DefaultContext,Notification,Param1,Param2);
switch(Notification) {
case SPFILENOTIFY_STARTQUEUE:
case SPFILENOTIFY_STARTSUBQUEUE:
case SPFILENOTIFY_ENDSUBQUEUE:
//
// Nothing is logged in this case.
//
break;
case SPFILENOTIFY_ENDQUEUE:
if(!Param1) {
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_QUEUE_ABORT, NULL,
SETUPLOG_USE_MESSAGEID,
GetLastError(),
NULL,NULL);
}
break;
case SPFILENOTIFY_STARTRENAME:
if(Status == FILEOP_SKIP) {
SysSetupContext->Skipped = TRUE;
} else {
SysSetupContext->Skipped = FALSE;
}
break;
case SPFILENOTIFY_ENDRENAME:
if(FilePaths->Win32Error == NO_ERROR &&
!SysSetupContext->Skipped) {
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_RENAMED,
FilePaths->Source,
FilePaths->Target,
NULL,NULL);
} else {
SetuplogError(
LogSevError,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_RENAME_ERROR,
FilePaths->Source,
FilePaths->Target, NULL,
SETUPLOG_USE_MESSAGEID,
FilePaths->Win32Error == NO_ERROR ?
MSG_LOG_USER_SKIP :
FilePaths->Win32Error,
NULL,NULL);
}
break;
case SPFILENOTIFY_RENAMEERROR:
if(Status == FILEOP_SKIP) {
SysSetupContext->Skipped = TRUE;
}
break;
case SPFILENOTIFY_STARTDELETE:
if(Status == FILEOP_SKIP) {
SysSetupContext->Skipped = TRUE;
} else {
SysSetupContext->Skipped = FALSE;
}
break;
case SPFILENOTIFY_ENDDELETE:
if(FilePaths->Win32Error == NO_ERROR &&
!SysSetupContext->Skipped) {
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_DELETED,
FilePaths->Target,
NULL,NULL);
} else if(FilePaths->Win32Error == ERROR_FILE_NOT_FOUND ||
FilePaths->Win32Error == ERROR_PATH_NOT_FOUND) {
//
// This failure is not important.
//
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_DELETE_ERROR,
FilePaths->Target, NULL,
SETUPLOG_USE_MESSAGEID,
FilePaths->Win32Error,
NULL,NULL);
} else {
//
// Here we have an actual error.
//
SetuplogError(
LogSevError,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_DELETE_ERROR,
FilePaths->Target, NULL,
SETUPLOG_USE_MESSAGEID,
FilePaths->Win32Error == NO_ERROR ?
MSG_LOG_USER_SKIP :
FilePaths->Win32Error,
NULL,NULL);
}
break;
case SPFILENOTIFY_DELETEERROR:
if(Status == FILEOP_SKIP) {
SysSetupContext->Skipped = TRUE;
}
break;
case SPFILENOTIFY_STARTCOPY:
if(Status == FILEOP_SKIP) {
SysSetupContext->Skipped = TRUE;
} else {
SysSetupContext->Skipped = FALSE;
}
break;
case SPFILENOTIFY_ENDCOPY:
if(FilePaths->Win32Error == NO_ERROR &&
!SysSetupContext->Skipped) {
LogRepairInfo(
FilePaths->Source,
FilePaths->Target
);
SetuplogError(
LogSevInformation,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_COPIED,
FilePaths->Source,
FilePaths->Target,
NULL,NULL);
//
// clear the file's readonly attribute that it may have gotten
// from the cdrom.
//
SetFileAttributes(
FilePaths->Target,
GetFileAttributes(FilePaths->Target) & ~FILE_ATTRIBUTE_READONLY );
} else {
SetuplogError(
LogSevError,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_FILE_COPY_ERROR,
FilePaths->Source,
FilePaths->Target, NULL,
SETUPLOG_USE_MESSAGEID,
FilePaths->Win32Error == NO_ERROR ?
MSG_LOG_USER_SKIP :
FilePaths->Win32Error,
NULL,NULL);
}
break;
case SPFILENOTIFY_COPYERROR:
if(Status == FILEOP_SKIP) {
SysSetupContext->Skipped = TRUE;
}
break;
case SPFILENOTIFY_NEEDMEDIA:
if(Status == FILEOP_SKIP) {
SetuplogError(
LogSevError,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_NEEDMEDIA_SKIP,
SourceMedia->SourceFile,
SourceMedia->SourcePath,
NULL,NULL);
SysSetupContext->Skipped = TRUE;
}
break;
case SPFILENOTIFY_STARTREGISTRATION:
case SPFILENOTIFY_ENDREGISTRATION:
RtlZeroMemory(&RegistrationContext,sizeof(RegistrationContext));
RegistrationQueueCallback(
&RegistrationContext,
Notification,
Param1,
Param2);
break;
default:
break;
}
return Status;
}
PSID
GetAdminAccountSid(
)
/*++
===============================================================================
Routine Description:
This routine gets the Adminstrator's SID
Arguments:
None.
Return Value:
TRUE - success.
FALSE - failed.
===============================================================================
--*/
{
BOOL b = TRUE;
LSA_HANDLE hPolicy;
NTSTATUS ntStatus;
OBJECT_ATTRIBUTES ObjectAttributes;
PPOLICY_ACCOUNT_DOMAIN_INFO AccountDomainInfo = NULL;
UCHAR SubAuthCount;
DWORD sidlen;
PSID psid = NULL;
InitializeObjectAttributes( &ObjectAttributes,
NULL,
0L,
NULL,
NULL );
ntStatus = LsaOpenPolicy( NULL,
&ObjectAttributes,
POLICY_ALL_ACCESS,
&hPolicy );
if (!NT_SUCCESS(ntStatus)) {
LsaClose(hPolicy);
b = FALSE;
}
if( b ) {
ntStatus = LsaQueryInformationPolicy( hPolicy,
PolicyAccountDomainInformation,
(PVOID *) &AccountDomainInfo );
LsaClose( hPolicy );
if (!NT_SUCCESS(ntStatus)) {
if ( AccountDomainInfo != NULL ) {
(VOID) LsaFreeMemory( AccountDomainInfo );
}
b = FALSE;
}
}
if( b ) {
//
// calculate the size of a new sid with one more SubAuthority
//
SubAuthCount = *(GetSidSubAuthorityCount ( AccountDomainInfo->DomainSid ));
SubAuthCount++; // for admin
sidlen = GetSidLengthRequired ( SubAuthCount );
//
// allocate and copy the new new sid from the Domain SID
//
psid = (PSID)malloc(sidlen);
if( psid ) {
memcpy(psid, AccountDomainInfo->DomainSid, GetLengthSid(AccountDomainInfo->DomainSid) );
//
// increment SubAuthority count and add Domain Admin RID
//
*(GetSidSubAuthorityCount( psid )) = SubAuthCount;
*(GetSidSubAuthority( psid, SubAuthCount-1 )) = DOMAIN_USER_RID_ADMIN;
if ( AccountDomainInfo != NULL ) {
(VOID) LsaFreeMemory( AccountDomainInfo );
}
}
}
return psid;
}
VOID
GetAdminAccountName(
PWSTR AccountName
)
/*++
===============================================================================
Routine Description:
This routine sets the Adminstrator Password
Arguments:
None.
Return Value:
TRUE - success.
FALSE - failed.
===============================================================================
--*/
{
BOOL b = TRUE;
LSA_HANDLE hPolicy;
NTSTATUS ntStatus;
OBJECT_ATTRIBUTES ObjectAttributes;
PPOLICY_ACCOUNT_DOMAIN_INFO AccountDomainInfo = NULL;
UCHAR SubAuthCount;
DWORD sidlen;
PSID psid;
WCHAR adminname[512];
WCHAR domainname[512];
DWORD adminlen=512; // address of size account string
DWORD domlen=512; // address of size account string
SID_NAME_USE sidtype;
//
// Initialize the administrator's account name.
//
LoadString(MyModuleHandle,IDS_ADMINISTRATOR,adminname,MAX_USERNAME+1);
InitializeObjectAttributes( &ObjectAttributes,
NULL,
0L,
NULL,
NULL );
ntStatus = LsaOpenPolicy( NULL,
&ObjectAttributes,
POLICY_ALL_ACCESS,
&hPolicy );
if (!NT_SUCCESS(ntStatus)) {
LsaClose(hPolicy);
b = FALSE;
}
if( b ) {
ntStatus = LsaQueryInformationPolicy( hPolicy,
PolicyAccountDomainInformation,
(PVOID *) &AccountDomainInfo );
LsaClose( hPolicy );
if (!NT_SUCCESS(ntStatus)) {
if ( AccountDomainInfo != NULL ) {
(VOID) LsaFreeMemory( AccountDomainInfo );
}
b = FALSE;
}
}
if( b ) {
//
// calculate the size of a new sid with one more SubAuthority
//
SubAuthCount = *(GetSidSubAuthorityCount ( AccountDomainInfo->DomainSid ));
SubAuthCount++; // for admin
sidlen = GetSidLengthRequired ( SubAuthCount );
//
// allocate and copy the new new sid from the Domain SID
//
psid = (PSID)malloc(sidlen);
if (psid) {
memcpy(psid, AccountDomainInfo->DomainSid, GetLengthSid(AccountDomainInfo->DomainSid) );
//
// increment SubAuthority count and add Domain Admin RID
//
*(GetSidSubAuthorityCount( psid )) = SubAuthCount;
*(GetSidSubAuthority( psid, SubAuthCount-1 )) = DOMAIN_USER_RID_ADMIN;
if ( AccountDomainInfo != NULL ) {
(VOID) LsaFreeMemory( AccountDomainInfo );
}
//
// get the admin account name from the new SID
//
LookupAccountSid( NULL,
psid,
adminname,
&adminlen,
domainname,
&domlen,
&sidtype );
}
}
lstrcpy( AccountName, adminname );
if (psid) {
free(psid);
}
}
ULONG
GetBatteryTag (HANDLE DriverHandle)
{
NTSTATUS Status;
IO_STATUS_BLOCK IOSB;
ULONG BatteryTag;
Status = NtDeviceIoControlFile(
DriverHandle,
(HANDLE) NULL, // event
(PIO_APC_ROUTINE) NULL,
(PVOID) NULL,
&IOSB,
IOCTL_BATTERY_QUERY_TAG,
NULL, // input buffer
0,
&BatteryTag, // output buffer
sizeof (BatteryTag)
);
if (!NT_SUCCESS(Status)) {
BatteryTag = BATTERY_TAG_INVALID;
if (Status == STATUS_NO_SUCH_DEVICE) {
SetupDebugPrint(L"(Battery is not physically present or is not connected)\n");
} else {
SetupDebugPrint1(L"Query Battery tag failed: Status = %x\n", Status);
}
}
return BatteryTag;
}
BOOLEAN
GetBatteryInfo (
HANDLE DriverHandle,
ULONG BatteryTag,
IN BATTERY_QUERY_INFORMATION_LEVEL Level,
OUT PVOID Buffer,
IN ULONG BufferLength
)
{
NTSTATUS Status;
IO_STATUS_BLOCK IOSB;
BATTERY_QUERY_INFORMATION BInfo;
memset (Buffer, 0, BufferLength);
BInfo.BatteryTag = BatteryTag;
BInfo.InformationLevel = Level;
BInfo.AtRate = 0; // This is needed for reading estimated time correctly.
Status = NtDeviceIoControlFile(
DriverHandle,
(HANDLE) NULL, // event
(PIO_APC_ROUTINE) NULL,
(PVOID) NULL,
&IOSB,
IOCTL_BATTERY_QUERY_INFORMATION,
&BInfo, // input buffer
sizeof (BInfo),
Buffer, // output buffer
BufferLength
);
if (!NT_SUCCESS(Status)) {
if ((Status == STATUS_INVALID_PARAMETER) ||
(Status == STATUS_INVALID_DEVICE_REQUEST) ||
(Status == STATUS_NOT_SUPPORTED)) {
SetupDebugPrint2(L"Not Supported by Battery, Level %x, Status: %x\n", Level, Status);
} else {
SetupDebugPrint2(L"Query failed: Level %x, Status = %x\n", Level, Status);
}
return FALSE;
}
return TRUE;
}
BOOLEAN
IsLongTermBattery(
PCWSTR BatteryName
)
{
HANDLE driverHandle;
ULONG batteryTag;
BATTERY_INFORMATION BInfo;
BOOLEAN Ret;
driverHandle = CreateFile (BatteryName,
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL,
NULL);
if (INVALID_HANDLE_VALUE == driverHandle) {
SetupDebugPrint2(L"Error opening %ws: GetLastError = 0x%08lx \n",
BatteryName, GetLastError());
return FALSE;
}
batteryTag = GetBatteryTag (driverHandle);
if (batteryTag == BATTERY_TAG_INVALID) {
NtClose(driverHandle);
return FALSE;
}
if (GetBatteryInfo (driverHandle, batteryTag, BatteryInformation, &BInfo, sizeof(BInfo))) {
Ret = !(BInfo.Capabilities & BATTERY_IS_SHORT_TERM);
} else {
Ret = FALSE;
}
NtClose(driverHandle);
return(Ret);
}
BOOLEAN
IsLaptop(
VOID
)
{
HDEVINFO devInfo;
SP_INTERFACE_DEVICE_DATA interfaceDevData;
PSP_INTERFACE_DEVICE_DETAIL_DATA funcClassDevData;
UCHAR index;
DWORD reqSize;
BOOLEAN b = FALSE;
devInfo = SetupDiGetClassDevs((LPGUID)&GUID_DEVICE_BATTERY, NULL, NULL,
DIGCF_PRESENT | DIGCF_INTERFACEDEVICE);
if (devInfo == INVALID_HANDLE_VALUE) {
SetupDebugPrint1(L"SetupDiGetClassDevs on GUID_DEVICE_BATTERY, failed: %d\n", GetLastError());
return FALSE;
}
interfaceDevData.cbSize = sizeof(SP_DEVINFO_DATA);
index = 0;
while(1) {
if (SetupDiEnumInterfaceDevice(devInfo,
0,
(LPGUID)&GUID_DEVICE_BATTERY,
index,
&interfaceDevData)) {
// Get the required size of the function class device data.
SetupDiGetInterfaceDeviceDetail(devInfo,
&interfaceDevData,
NULL,
0,
&reqSize,
NULL);
funcClassDevData = MyMalloc(reqSize);
if (funcClassDevData != NULL) {
funcClassDevData->cbSize =
sizeof(SP_INTERFACE_DEVICE_DETAIL_DATA);
if (SetupDiGetInterfaceDeviceDetail(devInfo,
&interfaceDevData,
funcClassDevData,
reqSize,
&reqSize,
NULL)) {
b = IsLongTermBattery(funcClassDevData->DevicePath);
}
else {
SetupDebugPrint1(L"SetupDiGetInterfaceDeviceDetail, failed: %d\n", GetLastError());
}
MyFree(funcClassDevData);
if (b) {
break;
}
}
} else {
if (ERROR_NO_MORE_ITEMS == GetLastError()) {
break;
}
else {
SetupDebugPrint1(L"SetupDiEnumInterfaceDevice, failed: %d\n", GetLastError());
}
}
index++;
}
SetupDiDestroyDeviceInfoList(devInfo);
return b;
}
VOID
SaveInstallInfoIntoEventLog(
VOID
)
/*++
Routine Description:
This routine will store information into the event log regarding
- if we upgraded or cleaninstall
- what build did the install originate from
- what build are we?
- were there errors during Setup
Arguments:
None.
Return Value:
None.
--*/
{
#define AnswerBufLen (64)
WCHAR AnswerFile[MAX_PATH];
WCHAR Answer[AnswerBufLen];
WCHAR OrigVersion[AnswerBufLen];
WCHAR NewVersion[AnswerBufLen];
HANDLE hEventSrc;
PCWSTR MyArgs[2];
PCWSTR ErrorArgs[1];
DWORD MessageID;
WORD MyArgCount;
//
// Go get the starting information out of $winnt$.sif
//
OrigVersion[0] = L'0';
OrigVersion[1] = L'\0';
GetSystemDirectory(AnswerFile,MAX_PATH);
pSetupConcatenatePaths(AnswerFile,WINNT_GUI_FILE,MAX_PATH,NULL);
if( GetPrivateProfileString( WINNT_DATA,
WINNT_D_WIN32_VER,
pwNull,
Answer,
AnswerBufLen,
AnswerFile ) ) {
if( lstrcmp( pwNull, Answer ) ) {
wsprintf( OrigVersion, L"%d", HIWORD(wcstoul( Answer, NULL, 16 )) );
}
}
MyArgs[1] = OrigVersion;
//
// Get the new version information.
//
wsprintf( NewVersion, L"%d", HIWORD(GetVersion()) );
MyArgs[0] = NewVersion;
//
// See if we're an NT upgrade?
//
MessageID = 0;
if( GetPrivateProfileString( WINNT_DATA,
WINNT_D_NTUPGRADE,
pwNo,
Answer,
AnswerBufLen,
AnswerFile ) ) {
if( !lstrcmp( pwYes, Answer ) ) {
MessageID = MSG_NTUPGRADE_SUCCESS;
MyArgCount = 2;
}
}
//
// See if we're a Win9X upgrade.
//
if( (!MessageID) &&
GetPrivateProfileString( WINNT_DATA,
WINNT_D_WIN95UPGRADE,
pwNo,
Answer,
AnswerBufLen,
AnswerFile ) ) {
if( !lstrcmp( pwYes, Answer ) ) {
MessageID = MSG_WIN9XUPGRADE_SUCCESS;
MyArgCount = 2;
}
}
//
// Clean install.
//
if( (!MessageID) ) {
MessageID = MSG_CLEANINSTALL_SUCCESS;
MyArgCount = 1;
}
//
// If this is anything but an NT upgrade, then
// we need to go try and manually start the eventlog
// service.
//
if( MessageID != MSG_NTUPGRADE_SUCCESS ) {
SetupStartService( L"Eventlog", TRUE );
}
//
// Get a handle to the eventlog.
//
hEventSrc = RegisterEventSource( NULL, L"Setup" );
if( (hEventSrc == NULL) ||
(hEventSrc == INVALID_HANDLE_VALUE) ) {
//
// Fail quietly.
//
return;
}
//
// Log event message for failure of SceSetupRootSecurity
//
if( !bSceSetupRootSecurityComplete) {
ErrorArgs[0] = L"%windir%";
ReportEvent( hEventSrc,
EVENTLOG_WARNING_TYPE,
0,
MSG_LOG_SCE_SETUPROOT_ERROR,
NULL,
1,
0,
ErrorArgs,
NULL );
}
//
// Log event if there were errors during Setup.
//
if ( !IsErrorLogEmpty() ) {
ReportEvent( hEventSrc,
EVENTLOG_ERROR_TYPE,
0,
MSG_NONFATAL_ERRORS,
NULL,
0,
0,
NULL,
NULL );
}
//
// Build the event log message.
//
ReportEvent( hEventSrc,
EVENTLOG_INFORMATION_TYPE,
0,
MessageID,
NULL,
MyArgCount,
0,
MyArgs,
NULL );
DeregisterEventSource( hEventSrc );
}
BOOL
IsEncryptedAdminPasswordPresent( VOID )
{
#define MD4HASHLEN ((2*(LM_OWF_PASSWORD_LENGTH + NT_OWF_PASSWORD_LENGTH))+2)
WCHAR AnswerFile[MAX_PATH+2];
WCHAR Answer[MD4HASHLEN];
//
// Get EncryptedAdminPassword from the Answer file
//
GetSystemDirectory(AnswerFile,MAX_PATH);
pSetupConcatenatePaths(AnswerFile,WINNT_GUI_FILE,MAX_PATH,NULL);
if( GetPrivateProfileString( WINNT_GUIUNATTENDED,
WINNT_US_ENCRYPTEDADMINPASS,
pwNull,
Answer,
MD4HASHLEN,
AnswerFile ) ) {
//
// See if we have an encrypted password. Now interpret the Admin Password differently
//
if( !lstrcmpi( WINNT_A_YES, Answer ) )
return TRUE;
}
return FALSE;
}
BOOL
ProcessEncryptedAdminPassword( PCWSTR AdminAccountName )
/*++
Routine Description:
This routine looks in the unattend file to see if there is an encrypted password and if present
sets the admin password to that.
Arguments:
AdminAccountName - Name of the administrator account whose password you want to set.
Returns:
Returns TRUE if it succeeds, FALSE on failure
--*/
{
#define MD4HASHLEN ((2*(LM_OWF_PASSWORD_LENGTH + NT_OWF_PASSWORD_LENGTH))+2)
WCHAR AnswerFile[MAX_PATH+2];
WCHAR Answer[MD4HASHLEN];
DWORD Err = NO_ERROR;
WCHAR adminName[MAX_USERNAME+1];
BOOLEAN ret = FALSE;
//
// Pickup the answer file.
//
GetSystemDirectory(AnswerFile,MAX_PATH);
pSetupConcatenatePaths(AnswerFile,WINNT_GUI_FILE,MAX_PATH,NULL);
//
// we look for the following keys in the [GUIUnattended] section:
//
//
// EncryptedAdminPassword = Yes | No
// AdminPassword = <MD4 Hash value>
//
if( IsEncryptedAdminPasswordPresent() ) {
//Fetch the Encrypted Admin Password
if( GetPrivateProfileString( WINNT_GUIUNATTENDED,
WINNT_US_ADMINPASS,
pwNull,
Answer,
MD4HASHLEN,
AnswerFile ) == (MD4HASHLEN-2) ) {
Err = SetLocalUserEncryptedPassword( AdminAccountName, L"", FALSE, Answer, TRUE );
if( Err == ERROR_SUCCESS) {
ret = TRUE;
}else{
//Log the error - MSG_LOG_CHANGING_ENCRYPT_PW_FAIL
SetuplogError(
LogSevWarning,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_CHANGING_ENCRYPT_PW_FAIL,
AdminAccountName, NULL,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_X_PARAM_RETURNED_WINERR,
L"SetLocalUserEncryptedPassword",
Err,
AdminAccountName,
NULL,NULL);
}
}else{
//Log that we had a bad encrypted password
SetuplogError(
LogSevError,
SETUPLOG_USE_MESSAGEID,
MSG_LOG_BAD_UNATTEND_PARAM,
WINNT_US_ADMINPASS,
WINNT_GUIUNATTENDED,
NULL,NULL);
}
}
return ret;
}
BOOL
FileExists(
IN PCTSTR FileName,
OUT PWIN32_FIND_DATA FindData OPTIONAL
)
/*++
Routine Description:
Determine if a file exists and is accessible.
Errormode is set (and then restored) so the user will not see
any pop-ups.
Arguments:
FileName - supplies full path of file to check for existance.
FindData - if specified, receives find data for the file.
Return Value:
TRUE if the file exists and is accessible.
FALSE if not. GetLastError() returns extended error info.
--*/
{
WIN32_FIND_DATA findData;
HANDLE FindHandle;
UINT OldMode;
DWORD Error;
OldMode = SetErrorMode(SEM_FAILCRITICALERRORS);
FindHandle = FindFirstFile(FileName,&findData);
if(FindHandle == INVALID_HANDLE_VALUE) {
Error = GetLastError();
} else {
FindClose(FindHandle);
if(FindData) {
*FindData = findData;
}
Error = NO_ERROR;
}
SetErrorMode(OldMode);
SetLastError(Error);
return (Error == NO_ERROR);
}
BOOL IsSafeMode(
VOID
)
{
LONG lStatus;
HKEY hk;
DWORD dwVal;
DWORD dwType;
DWORD dwSize;
lStatus = RegOpenKeyExW(HKEY_LOCAL_MACHINE, SAFEBOOT_OPTION_KEY, 0, KEY_QUERY_VALUE, &hk);
if(lStatus != ERROR_SUCCESS)
return FALSE;
dwSize = sizeof(dwVal);
lStatus = RegQueryValueExW(hk, OPTION_VALUE, NULL, &dwType, (LPBYTE) &dwVal, &dwSize);
RegCloseKey(hk);
return ERROR_SUCCESS == lStatus && REG_DWORD == dwType && dwVal != 0;
}
void
SetupCrashRecovery(
VOID
)
/*
Setup the Crash Recovery stuff. This is implemented as RTL APIS
This call sets up the tracking file etc. Crash Recovery tracks boot and
shutdown and in the event of failures in either it will by default pick the
right advanced boot option.
*/
{
HANDLE BootStatusData;
NTSTATUS Status;
BOOLEAN Enabled;
UCHAR Timeout = 30; //default = 30 sec
WCHAR Buffer[10];
PSTR AnsiBuffer;
int p = 0;
//
// We enable the feature for Pro and Per. On Server SKUs
// we create the file but don't enable the feature by default.
//
if( ProductType == PRODUCT_WORKSTATION ){
Enabled = TRUE;
}else{
Enabled = FALSE;
}
//
// For the fresh install case create the boot status data file
// and setup the default settings. In the case of an upgrade
// we will set the previous values if we find them in $winnt$.inf
// as textmode setup would have stored this away for us. If not we
// proceed as if we were fresh.
//
if( Upgrade ){
//Look for settings in $winnt$.inf
if( SpSetupLoadParameter( WINNT_D_CRASHRECOVERYENABLED, Buffer, sizeof(Buffer)/sizeof(WCHAR))){
if (_wcsicmp(Buffer, L"NO") == 0) {
Enabled = FALSE;
}
//
//We do the below check also as we might have to migrate settings on server SKUs
//that have this enabled. By default they are disabled.
//
if (_wcsicmp(Buffer, L"YES") == 0) {
Enabled = TRUE;
}
}
}
Status = RtlLockBootStatusData( &BootStatusData );
// This is the first time or there was no file. Create it
if( !NT_SUCCESS( Status )){
Status = RtlCreateBootStatusDataFile();
if( !NT_SUCCESS( Status )){
SetuplogError(
LogSevWarning,
L"Setup: (non-critical error) Could not lock the Crash Recovery status file - (%1!x!)\n",
0,Status,NULL,NULL);
return;
}
//Lock the file
Status = RtlLockBootStatusData( &BootStatusData );
if( !NT_SUCCESS( Status )){
SetupDebugPrint1( L"Setup: (non-critical error) Could not lock the Crash Recovery status file - (%x)\n", Status );
return;
}
Status = RtlGetSetBootStatusData(
BootStatusData,
FALSE,
RtlBsdItemAabTimeout,
&Timeout,
sizeof(UCHAR),
NULL
);
if( !NT_SUCCESS( Status )){
SetupDebugPrint1( L"Setup: (non-critical error) Could not set the Crash Recovery timeout - (%x)\n", Status );
goto SCR_done;
}
}
Status = RtlGetSetBootStatusData(
BootStatusData,
FALSE,
RtlBsdItemAabEnabled,
&Enabled,
sizeof(BOOLEAN),
NULL
);
if( !NT_SUCCESS( Status )){
SetupDebugPrint1( L"Setup: (non-critical error) Could not enable Crash Recovery - (%x)\n", Status );
}
SCR_done:
RtlUnlockBootStatusData( BootStatusData );
return;
}
DWORD
BuildFileListFromDir(
IN PCTSTR PathBase,
IN PCTSTR Directory OPTIONAL,
IN DWORD MustHaveAttrs OPTIONAL,
IN DWORD MustNotHaveAttrs OPTIONAL,
IN PFN_BUILD_FILE_LIST_CALLBACK Callback OPTIONAL,
OUT PLIST_ENTRY ListHead
)
/*++
Routine Description:
Builds a linked list containing the names (without path) of files present in a specified directory.
The files must meed a set of conditions as specified by the arguments.
Arguments:
PathBase - The path to the directory to enumerate files in.
Directory - If not NULL or empty, it is appended to PathBase to form a complete path to the directory.
MustHaveAttrs - A set of attributes a file must have to be included on the list.
MustNotHaveAttrs - A set of attributes a file must not have to be included on the list.
Callback - If not NULL, this function will be called and the file will be included on the list only
if it returns TRUE.
ListHead - Pointer to the head of the list to be filled in.
Return value:
ERROR_SUCCESS on success, otherwise a Win32 error code. The list may not be empty even if the function fails; the caller
must always empty the list.
--*/
{
DWORD Error = ERROR_SUCCESS;
HANDLE hFind = INVALID_HANDLE_VALUE;
PTSTR szPath = NULL;
WIN32_FIND_DATA fd;
if(ListHead != NULL) {
InitializeListHead(ListHead);
}
if(NULL == PathBase || 0 == PathBase[0] || NULL == ListHead) {
Error = ERROR_INVALID_PARAMETER;
goto exit;
}
szPath = (PTSTR) MyMalloc(MAX_PATH * sizeof(TCHAR));
if(NULL == szPath) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
_tcsncpy(szPath, PathBase, MAX_PATH - 1);
szPath[MAX_PATH - 1] = 0;
if(Directory != NULL && Directory[0] != 0) {
pSetupConcatenatePaths(szPath, Directory, MAX_PATH, NULL);
}
if(!pSetupConcatenatePaths(szPath, TEXT("\\*"), MAX_PATH, NULL)) {
Error = ERROR_BAD_PATHNAME;
goto exit;
}
hFind = FindFirstFile(szPath, &fd);
if(INVALID_HANDLE_VALUE == hFind) {
Error = GetLastError();
if(ERROR_FILE_NOT_FOUND == Error || ERROR_PATH_NOT_FOUND == Error) {
Error = ERROR_SUCCESS;
}
goto exit;
}
//
// We might need the dir later
//
(_tcsrchr(szPath, L'\\'))[0] = 0;
do {
if(_tcscmp(fd.cFileName, _T(".")) != 0 &&
_tcscmp(fd.cFileName, _T("..")) != 0 &&
(MustHaveAttrs & fd.dwFileAttributes) == MustHaveAttrs &&
0 == (MustNotHaveAttrs & fd.dwFileAttributes) &&
(NULL == Callback || Callback(szPath, fd.cFileName))) {
ULONG uLen;
PSTRING_LIST_ENTRY pElem = (PSTRING_LIST_ENTRY) MyMalloc(sizeof(STRING_LIST_ENTRY));
if(NULL == pElem) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
uLen = (_tcslen(fd.cFileName) + 1) * sizeof(TCHAR);
pElem->String = (PTSTR) MyMalloc(uLen);
if(NULL == pElem->String) {
MyFree(pElem);
Error = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
RtlCopyMemory(pElem->String, fd.cFileName, uLen);
InsertTailList(ListHead, &pElem->Entry);
}
}
while(FindNextFile(hFind, &fd));
Error = GetLastError();
if(ERROR_NO_MORE_FILES == Error) {
Error = ERROR_SUCCESS;
}
exit:
if(hFind != INVALID_HANDLE_VALUE) {
FindClose(hFind);
}
if(szPath != NULL) {
MyFree(szPath);
}
return Error;
}
PSTRING_LIST_ENTRY
SearchStringInList(
IN PLIST_ENTRY ListHead,
IN PCTSTR String,
BOOL CaseSensitive
)
/*++
Routine Description:
This routine searches for a string in a string list. The string can be NULL or empty, in which
case the function returns the first entry in the list with a NULL or empty string.
Arguments:
ListHead - Pointer to the head of the list to be searched.
String - Specifies the string to search for.
CaseSensitive - If TRUE, the search will be case sensitive.
Return value:
A pointer to the first entry containing the string, if found, or NULL otherwise.
--*/
{
if(ListHead != NULL)
{
PLIST_ENTRY pEntry;
ULONG uLen1 = (String != NULL ? _tcslen(String) : 0);
for(pEntry = ListHead->Flink; pEntry != ListHead; pEntry = pEntry->Flink) {
PSTRING_LIST_ENTRY pStringEntry;
ULONG uLen2;
pStringEntry = CONTAINING_RECORD(pEntry, STRING_LIST_ENTRY, Entry);
uLen2 = (pStringEntry->String != NULL ? _tcslen(pStringEntry->String) : 0);
if(uLen1 == uLen2) {
if(0 == uLen1 || 0 == (CaseSensitive ? _tcscmp : _tcsicmp)(String, pStringEntry->String)) {
return pStringEntry;
}
}
}
}
return NULL;
}
DWORD
LookupCatalogAttribute(
IN PCWSTR CatalogName,
IN PCWSTR Directory OPTIONAL,
IN PCWSTR AttributeName OPTIONAL,
IN PCWSTR AttributeValue OPTIONAL,
PBOOL Found
)
/*++
Routine Description:
This function searches if a catalog has the specified attribute with the specified value.
Arguments:
CatalogName - Name of the catalog to search. A path can be specified.
Directory - If specified, it is prepended to CatalogName to form the path to the catalog.
AttributeName - See AttributeValue.
AttributeValue - If AttributeName and AttributeValue are not specified, the catalog meets the condition.
If AttributeName is specified and AttributeValue isn't, the catalog meets the condition if
it contains an attribute with AttributeName name and any value. If AttributeName is not
specified and AttributeValue is, the catalog meets the condition if it contains an attribute
with AttributeValue value and any name. If both AttributeName and AttributeValue are
specified, the catalog meets the condition if it contains an attribute with AttributeName name
and AttributeValue value.
Found - Pointer to a variable that receives TRUE if the catalog meets the condition, or FALSE otherwise.
Return value:
ERROR_SUCCESS if successful, otherwise a Win32 error code.
--*/
{
DWORD Error = ERROR_SUCCESS;
HANDLE hCat = INVALID_HANDLE_VALUE;
PWSTR szCatPath = NULL;
CRYPTCATATTRIBUTE* pAttr;
if(Found != NULL) {
*Found = FALSE;
}
if(NULL == CatalogName || 0 == CatalogName[0] || NULL == Found) {
Error = ERROR_INVALID_PARAMETER;
goto exit;
}
if(Directory != NULL && Directory[0] != 0) {
szCatPath = MyMalloc(MAX_PATH * sizeof(WCHAR));
if(NULL == szCatPath) {
Error = ERROR_NOT_ENOUGH_MEMORY;
goto exit;
}
_tcsncpy(szCatPath, Directory, MAX_PATH - 1);
szCatPath[MAX_PATH - 1] = 0;
pSetupConcatenatePaths(szCatPath, CatalogName, MAX_PATH, NULL);
CatalogName = szCatPath;
}
//
// This is easier to test
//
if(AttributeName != NULL && 0 == AttributeName[0]) {
AttributeName = NULL;
}
if(AttributeValue != NULL && 0 == AttributeValue[0]) {
AttributeValue = NULL;
}
if(NULL == AttributeName && NULL == AttributeValue) {
//
// If attribute name and value are not specified, any catalog is a match
//
*Found = TRUE;
goto exit;
}
hCat = CryptCATOpen((PWSTR) CatalogName, CRYPTCAT_OPEN_EXISTING, 0, 0, 0);
if(INVALID_HANDLE_VALUE == hCat) {
Error = GetLastError();
goto exit;
}
pAttr = CryptCATEnumerateCatAttr(hCat, NULL);
while(pAttr != NULL) {
*Found = (NULL == AttributeName || 0 == _wcsicmp(AttributeName, pAttr->pwszReferenceTag)) &&
(NULL == AttributeValue || 0 == _wcsicmp(AttributeName, (PCWSTR) pAttr->pbValue));
if(*Found) {
goto exit;
}
pAttr = CryptCATEnumerateCatAttr(hCat, pAttr);
}
Error = GetLastError();
if(CRYPT_E_NOT_FOUND == Error) {
Error = ERROR_SUCCESS;
}
exit:
if(szCatPath != NULL) {
MyFree(szCatPath);
}
if(hCat != INVALID_HANDLE_VALUE) {
CryptCATClose(hCat);
}
return Error;
}
Reference in a new issue Copy permalink