|
|
/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
bootini.c
Abstract:
Code to lay boot blocks on x86, and to configure for boot loader, including munging/creating boot.ini and bootsect.dos.
Author:
Ted Miller (tedm) 12-November-1992
Revision History:
Sunil Pai ( sunilp ) 2-November-1993 rewrote for new text setup
--*/
#include "spprecmp.h"
#pragma hdrstop
#include "spboot.h"
#include "bootvar.h"
#include "spfile.h" //NEC98
#include <hdlsblk.h>
#include <hdlsterm.h>
extern PDISK_REGION TargetRegion_Nec98; //NEC98
SIGNATURED_PARTITIONS SignedBootVars;
BOOLEANSpHasMZHeader( IN PWSTR FileName );
NTSTATUSSpx86WriteBootIni( IN PWCHAR BootIni, IN PWSTR **BootVars, IN ULONG Timeout, IN PWSTR Default, IN ULONG Count );
//
// DefSwitches support
//
UCHAR DefSwitches[128];UCHAR DefSwitchesNoRedirect[128];
//
// Routines
//
BOOLEANSpx86InitBootVars( OUT PWSTR **BootVars, OUT PWSTR *Default, OUT PULONG Timeout ){ WCHAR BootIni[512]; HANDLE FileHandle; HANDLE SectionHandle; PVOID ViewBase; NTSTATUS Status; ULONG FileSize; PUCHAR BootIniBuf; PDISK_REGION CColonRegion; BOOTVAR i; PUCHAR p; ULONG index;
//
// Initialize the defaults
//
for(i = FIRSTBOOTVAR; i <= LASTBOOTVAR; i++) { BootVars[i] = (PWSTR *)SpMemAlloc( sizeof ( PWSTR * ) ); ASSERT( BootVars[i] ); *BootVars[i] = NULL; } *Default = NULL; *Timeout = DEFAULT_TIMEOUT;
//
// See if there is a valid C: already. If not, then silently fail.
//
if (!IsNEC_98 // NEC98
#if defined(REMOTE_BOOT)
|| RemoteBootSetup#endif // defined(REMOTE_BOOT)
) {
#if defined(REMOTE_BOOT)
if (RemoteBootSetup && !RemoteInstallSetup) { ASSERT(RemoteBootTargetRegion != NULL); CColonRegion = RemoteBootTargetRegion; } else#endif // defined(REMOTE_BOOT)
{ CColonRegion = SpPtValidSystemPartition(); if(!CColonRegion) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "SETUP: no C:, no boot.ini!\n")); return(TRUE); } }
//
// Form name of file. Boot.ini better not be on a doublespace drive.
//
ASSERT(CColonRegion->Filesystem != FilesystemDoubleSpace); SpNtNameFromRegion(CColonRegion,BootIni,sizeof(BootIni),PartitionOrdinalCurrent); SpConcatenatePaths(BootIni,WBOOT_INI);
//
// Open and map the file.
//
FileHandle = 0; Status = SpOpenAndMapFile(BootIni,&FileHandle,&SectionHandle,&ViewBase,&FileSize,FALSE); if(!NT_SUCCESS(Status)) { return TRUE; }
//
// Allocate a buffer for the file.
//
BootIniBuf = SpMemAlloc(FileSize+1); ASSERT(BootIniBuf); RtlZeroMemory(BootIniBuf, FileSize+1);
//
// Transfer boot.ini into the buffer. We do this because we also
// want to place a 0 byte at the end of the buffer to terminate
// the file.
//
// Guard the RtlMoveMemory because if we touch the memory backed by boot.ini
// and get an i/o error, the memory manager will raise an exception.
try { RtlMoveMemory(BootIniBuf,ViewBase,FileSize); } except( IN_PAGE_ERROR ) { //
// Do nothing, boot ini processing can proceed with whatever has been
// read
//
}
//
// Not needed since buffer has already been zeroed, however just do this
// just the same
//
BootIniBuf[FileSize] = 0;
//
// Cleanup
//
SpUnmapFile(SectionHandle,ViewBase); ZwClose(FileHandle);
} else { //NEC98
//
// Serch for all drive which include boot.ini file.
//
FileSize = 0; BootIniBuf = SpCreateBootiniImage(&FileSize);
if(BootIniBuf == NULL){ return(TRUE); }
} //NEC98
//
// Do the actual processing of the file.
//
SppProcessBootIni(BootIniBuf, BootVars, Default, Timeout);
//
// Dump the boot vars
//
KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "Spx86InitBootVars - Boot.ini entries:\n") ); for( index = 0; BootVars[OSLOADPARTITION][index] ; index++ ) { KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, " BootVar: %d\n =========\n", index) ); KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, " OsLoadpartition: %ws\n", BootVars[OSLOADPARTITION][index]) ); KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, " OsLoadFileName: %ws\n\n", BootVars[OSLOADFILENAME][index]) ); }
//
// Dump the signatures too...
//
KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "Spx86InitBootVars - Boot.ini signed entries:\n") ); { SIGNATURED_PARTITIONS *my_ptr = &SignedBootVars; do{ if( my_ptr->SignedString ) { KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "Signature entry:\n================\n") ); KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, " %ws\n", my_ptr->SignedString) ); KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, " %ws\n", my_ptr->MultiString) );
}; my_ptr = my_ptr->Next; } while( my_ptr ); }
//
// Scan the Buffer to see if there is a DefSwitches line,
// to move into new boot.ini in the [boot loader] section.
// If no DefSwitches, just point to a null string to be moved.
//
DefSwitches[0] = '\0'; for(p=BootIniBuf; *p && (p < BootIniBuf+FileSize-(sizeof("DefSwitches")-1)); p++) { if(!_strnicmp(p,"DefSwitches",sizeof("DefSwitches")-1)) { index = 0; while ((*p != '\r') && (*p != '\n') && *p && (index < sizeof(DefSwitches)-4)) { DefSwitches[index++] = *p++; } DefSwitches[index++] = '\r'; DefSwitches[index++] = '\n'; DefSwitches[index] = '\0'; break; } }
//
// get a copy of the defswitches without any redirection switches
//
strcpy(DefSwitchesNoRedirect, DefSwitches);
//
// Now add any headless parameters to the default switches.
// Scan the Buffer to see if there's already a headless line.
// If so, keep it.
//
for(p=BootIniBuf; *p && (p < BootIniBuf+FileSize-(sizeof("redirect=")-1)); p++) {
if(!_strnicmp(p,"[Operat",sizeof("[Operat")-1)) {
//
// We're past the [Boot Loader] section. Stop looking.
//
break; }
if(!_strnicmp(p,"redirect=",sizeof("redirect=")-1)) {
PUCHAR q = p; UCHAR temp;
while ((*p != '\r') && (*p != '\n') && *p) { p++; } temp = *p; *p = '\0'; strcat(DefSwitches, q); strcat(DefSwitches, "\r\n"); *p = temp; } }
//
// Now look for a 'redirectbaudrate' line.
//
for(p=BootIniBuf; *p && (p < BootIniBuf+FileSize-(sizeof("redirectbaudrate=")-1)); p++) {
if(!_strnicmp(p,"[Operat",sizeof("[Operat")-1)) {
//
// We're past the [Boot Loader] section. Stop looking.
//
break; }
if(!_strnicmp(p,"redirectbaudrate=",sizeof("redirectbaudrate=")-1)) {
PUCHAR q = p; UCHAR temp;
while ((*p != '\r') && (*p != '\n') && *p) { p++; } temp = *p; *p = '\0'; strcat(DefSwitches, q); strcat(DefSwitches, "\r\n"); *p = temp; } }
SpMemFree(BootIniBuf); return( TRUE );}
BOOLEANSpx86FlushBootVars( IN PWSTR **BootVars, IN ULONG Timeout, IN PWSTR Default ){ PDISK_REGION CColonRegion; WCHAR *BootIni; WCHAR *BootIniBak; BOOLEAN BootIniBackedUp = FALSE;
NTSTATUS Status;
//
// See if there is a valid C: already. If not, then fail.
//
#if defined(REMOTE_BOOT)
// On a remote boot machine, it's acceptable to have no local disk.
//
#endif // defined(REMOTE_BOOT)
if (!IsNEC_98){ //NEC98
CColonRegion = SpPtValidSystemPartition(); if(!CColonRegion) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "SETUP: no C:, no boot.ini!\n"));#if defined(REMOTE_BOOT)
if (RemoteBootSetup && !RemoteInstallSetup) { return(TRUE); }#endif // defined(REMOTE_BOOT)
return(FALSE); } } else { //
// CColonRegion equal TargetRegion on NEC98.
//
CColonRegion = TargetRegion_Nec98; } //NEC98
//
// Allocate the buffers to 2K worth of stack space.
//
BootIni = SpMemAlloc(512*sizeof(WCHAR)); if (!BootIni) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: No memory for boot.ini!\n")); return FALSE; }
BootIniBak = SpMemAlloc(512*sizeof(WCHAR)); if (!BootIniBak) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: No memory for boot.ini.bak!\n")); SpMemFree(BootIni); return FALSE; }
//
// Form name of file. Boot.ini better not be on a doublespace drive.
//
ASSERT(CColonRegion->Filesystem != FilesystemDoubleSpace); SpNtNameFromRegion(CColonRegion,BootIni,512*sizeof(WCHAR),PartitionOrdinalCurrent); wcscpy(BootIniBak, BootIni); SpConcatenatePaths(BootIni,WBOOT_INI); SpConcatenatePaths(BootIniBak,WBOOT_INI_BAK);
//
// If Boot.ini already exists, delete any backup bootini
// rename the existing bootini to the backup bootini, if unable
// to rename, delete the file
//
if( SpFileExists( BootIni, FALSE ) ) {
if( SpFileExists( BootIniBak, FALSE ) ) { SpDeleteFile( BootIniBak, NULL, NULL); }
Status = SpRenameFile( BootIni, BootIniBak, FALSE ); if (!(BootIniBackedUp = NT_SUCCESS( Status ))) { SpDeleteFile( BootIni, NULL, NULL ); } }
//
// Write boot.ini.
//
Status = Spx86WriteBootIni( BootIni, BootVars, Timeout, Default, 0 // write all lines
);
if(!NT_SUCCESS( Status )) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Error writing boot.ini!\n")); goto cleanup; }
cleanup:
//
// If we were unsuccessful in writing out boot ini then try recovering
// the old boot ini from the backed up file, else delete the backed up
// file.
//
if( !NT_SUCCESS(Status) ) {
//
// If the backup copy of boot ini exists then delete incomplete boot
// ini and rename the backup copy of boot into bootini
//
if ( BootIniBackedUp ) { SpDeleteFile( BootIni, NULL, NULL ); SpRenameFile( BootIniBak, BootIni, FALSE ); }
} else {
SpDeleteFile( BootIniBak, NULL, NULL );
}
SpMemFree(BootIni); SpMemFree(BootIniBak);
return( NT_SUCCESS(Status) );}
PCHARSpx86ConvertToSignatureArcName( IN PWSTR ArcPathIn, IN ULONG Signature ){ PWSTR s,p,b; PWSTR UseSignatures; SIGNATURED_PARTITIONS *SignedEntries = &SignedBootVars;
KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "Spx86ConvertToSignatureArcName - Incoming ArcPath: %ws\n\tIncoming Signature %lx\n", ArcPathIn, Signature ) );
//
// First, check for any boot.ini entries that already had a 'signature'
// string.
//
do { if( (SignedEntries->MultiString) && (SignedEntries->SignedString) ) { if( !_wcsicmp( ArcPathIn, SignedEntries->MultiString ) ) {
//
// We hit. Convert the signatured string
// to ASCII and return.
//
KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "Spx86ConvertToSignatureArcName - Matched a multi-signed boot.ini entry:\n") ); KdPrintEx( (DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "\t%ws\n\t%ws\n", SignedEntries->MultiString, SignedEntries->SignedString) ); return SpToOem( SignedEntries->SignedString ); }
}
SignedEntries = SignedEntries->Next; } while( SignedEntries );
#if 0
//
// Don't do this because winnt.exe and CDROM-boot installs won't
// have this entry set, so we won't use signature entries, which
// is a mistake.
//
UseSignatures = SpGetSectionKeyIndex(WinntSifHandle,SIF_DATA,L"UseSignatures",0); if (UseSignatures == NULL || _wcsicmp(UseSignatures,WINNT_A_YES_W) != 0) { //
// Just return the string we came in with.
//
return SpToOem(ArcPathIn); }#endif
if (_wcsnicmp( ArcPathIn, L"scsi(", 5 ) != 0) { //
// If he's anything but a "scsi(..." entry,
// just return the string that was sent in.
//
return SpToOem(ArcPathIn); } if( Signature ) { b = (PWSTR)TemporaryBuffer; p = ArcPathIn; s = wcschr( p, L')' ) + 1; swprintf( b, L"signature(%x)%ws", Signature, s ); return SpToOem( b ); } else { //
// Just return the string we came in with.
//
return SpToOem(ArcPathIn); }}
NTSTATUSSpx86WriteBootIni( IN PWCHAR BootIni, IN PWSTR **BootVars, IN ULONG Timeout, IN PWSTR Default, IN ULONG Count ){ IO_STATUS_BLOCK IoStatusBlock; UNICODE_STRING BootIni_U; HANDLE fh = NULL; PCHAR Default_O, Osloadpartition_O, Osloadfilename_O, Osloadoptions_O, Loadidentifier_O; FILE_BASIC_INFORMATION BasicInfo; OBJECT_ATTRIBUTES oa; ULONG i; NTSTATUS Status1; NTSTATUS Status; PWSTR s; PDISK_REGION Region; WCHAR _Default[MAX_PATH] = {0}; extern ULONG DefaultSignature;
//
// Open Bootini file. Open if write through because we'll be shutting down
// shortly (this is for safety).
//
RtlInitUnicodeString(&BootIni_U,BootIni); InitializeObjectAttributes(&oa,&BootIni_U,OBJ_CASE_INSENSITIVE,NULL,NULL); Status = ZwCreateFile( &fh, FILE_GENERIC_WRITE | DELETE, &oa, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, 0, // no sharing
FILE_OVERWRITE_IF, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_WRITE_THROUGH, NULL, 0 );
if( !NT_SUCCESS( Status ) ) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unable to open %ws for writing!\n", BootIni)); goto cleanup; }
//
// make sure there is a Default specified before we use it.
//
if (Default != NULL) { //
// use the temporary buffer to form the FLEXBOOT section.
// and then write it out
//
s = NULL; s = wcschr( Default, L'\\' ); if( s ) { //
// Save off the Default string, then terminate
// the Default string where the directory path starts.
//
wcscpy( _Default, Default ); *s = L'\0'; s = wcschr( _Default, L'\\' ); }
if( ForceBIOSBoot ) { //
// If ForceBIOSBoot is TRUE, then we want to
// force a "multi(..." string. Don't even bother calling
// Spx86ConvertToSignatureArcName on the off chance
// that we may get erroneously converted.
//
if (_wcsnicmp( Default, L"scsi(", 5 ) == 0) { PWSTR MyStringPointer = NULL;
//
// Darn! We have a string that the old standard
// thought should be converted into a signature(...
// string, but we didn't write out a miniport driver.
// That can happen if someone asked us not to via
// an unattend switch.
//
// We need to change the "scsi(" to "multi("
//
// We must preserve Default because we use it later
// for comparison.
//
MyStringPointer = SpScsiArcToMultiArc( Default );
if( MyStringPointer ) { Default_O = SpToOem( MyStringPointer ); } else { //
// We're in trouble. Take a shot though. Just
// change the "scsi(" part to "multi(".
//
wcscpy( TemporaryBuffer, L"multi" ); wcscat( TemporaryBuffer, &Default[4] );
Default_O = SpToOem( TemporaryBuffer ); } } else { //
// Just convert to ANSI.
//
Default_O = SpToOem( Default );
} } else { Default_O = Spx86ConvertToSignatureArcName( Default, DefaultSignature ); }
if( s ) { //
// We need to append our directory path back on.
//
strcpy( (PCHAR)TemporaryBuffer, Default_O ); SpMemFree( Default_O ); Default_O = SpToOem( s ); strcat( (PCHAR)TemporaryBuffer, Default_O ); SpMemFree( Default_O ); Default_O = SpDupString( (PCHAR)TemporaryBuffer ); }
if (Default_O == NULL) { Default_O = SpToOem( Default ); } } else {
//
// the Default was not set, so make a null Default_O
//
Default_O = SpDupString("");
} ASSERT( Default_O );
//
// See if we should use the loaded redirect switches,
// if there were any, or insert user defined swithes
//
if(RedirectSwitchesMode != UseDefaultSwitches) {
//
// get a copy of the switches up to the [operat region
//
strcpy(DefSwitches, DefSwitchesNoRedirect);
//
// insert our custom switch(s) if appropriate
//
switch(RedirectSwitchesMode){ case DisableRedirect: { //
// we don't have to do anything here
//
break; } case UseUserDefinedRedirect: { sprintf((PUCHAR)TemporaryBuffer, "redirect=%s\r\n", RedirectSwitches.port );
(void)StringCchCatA(DefSwitches, sizeof(DefSwitches)/sizeof(DefSwitches[0]), (PUCHAR)TemporaryBuffer); break; } case UseUserDefinedRedirectAndBaudRate: { sprintf((PUCHAR)TemporaryBuffer, "redirect=%s\r\n", RedirectSwitches.port );
(void)StringCchCatA(DefSwitches, sizeof(DefSwitches)/sizeof(DefSwitches[0]), (PUCHAR)TemporaryBuffer); sprintf((PUCHAR)TemporaryBuffer, "redirectbaudrate=%s\r\n", RedirectSwitches.baudrate );
(void)StringCchCatA(DefSwitches, sizeof(DefSwitches)/sizeof(DefSwitches[0]), (PUCHAR)TemporaryBuffer); break; } default:{ ASSERT(0); } }
} else { //
// Make sure the required headless settings are already in the DefSwitches string before
// we write it out.
//
_strlwr( DefSwitches );
if( !strstr(DefSwitches, "redirect") ) {
PUCHAR p; HEADLESS_RSP_QUERY_INFO Response; SIZE_T Length;
//
// There are no headless settings. See if we need to add any.
//
Length = sizeof(HEADLESS_RSP_QUERY_INFO); Status = HeadlessDispatch(HeadlessCmdQueryInformation, NULL, 0, &Response, &Length );
p=NULL;
if (NT_SUCCESS(Status) && (Response.PortType == HeadlessSerialPort) && Response.Serial.TerminalAttached) {
if (Response.Serial.UsedBiosSettings) {
strcat(DefSwitches, "redirect=UseBiosSettings\r\n");
} else {
switch (Response.Serial.TerminalPort) { case ComPort1: p = "redirect=com1\r\n"; break; case ComPort2: p = "redirect=com2\r\n"; break; case ComPort3: p = "redirect=com3\r\n"; break; case ComPort4: p = "redirect=com4\r\n"; break; default: ASSERT(0); p = NULL; break; }
if (p) { strcat(DefSwitches, p); }
//
// Now take care of the 'redirectbaudrate' entry.
//
switch (Response.Serial.TerminalBaudRate) { case 115200: p = "redirectbaudrate=115200\r\n"; break; case 57600: p = "redirectbaudrate=57600\r\n"; break; case 19200: p = "redirectbaudrate=19200\r\n"; break; default: p = "redirectbaudrate=9600\r\n"; break; }
strcat(DefSwitches, p); } } } }
sprintf( (PUCHAR)TemporaryBuffer, "%s%s%s%s%s%ld%s%s%s%s%s", FLEXBOOT_SECTION2, CRLF, DefSwitches, TIMEOUT, EQUALS, Timeout, CRLF, DEFAULT, EQUALS, Default_O, CRLF );
SpMemFree( Default_O );
Status = ZwWriteFile( fh, NULL, NULL, NULL, &IoStatusBlock, TemporaryBuffer, strlen((PUCHAR)TemporaryBuffer) * sizeof(UCHAR), NULL, NULL );
if(!NT_SUCCESS( Status )) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Error writing %s section to %ws!\n", FLEXBOOT_SECTION2, BootIni)); goto cleanup; }
//
// Now write the BOOTINI_OS_SECTION label to boot.ini
//
sprintf( (PUCHAR)TemporaryBuffer, "%s%s", BOOTINI_OS_SECTION, CRLF );
Status = ZwWriteFile( fh, NULL, NULL, NULL, &IoStatusBlock, TemporaryBuffer, strlen((PUCHAR)TemporaryBuffer) * sizeof(UCHAR), NULL, NULL );
if(!NT_SUCCESS( Status )) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Error writing %s section to %ws!\n", BOOTINI_OS_SECTION, BootIni)); goto cleanup; }
//
// run through all the systems that we have and write them out
//
for( i = 0; BootVars[OSLOADPARTITION][i] ; i++ ) {
//
// If we were told to write a specified number of lines, exit
// when we have done that.
//
if (Count && (i == Count)) { Status = STATUS_SUCCESS; goto cleanup; }
ASSERT( BootVars[OSLOADFILENAME][i] ); ASSERT( BootVars[OSLOADOPTIONS][i] ); ASSERT( BootVars[LOADIDENTIFIER][i] );
//
// On some upgrades, if we're upgrading a "signature" entry,
// then we may not have a DefaultSignature. I fixed that case over
// in Spx86ConvertToSignatureArcName. The other case is where
// we have a DefaultSignature, but there are also some "scsi(..."
// entries in the boot.ini that don't pertain to the entry we're
// upgrading. For that case, we need to send in a signature
// of 0 here, which will force Spx86ConvertToSignatureArcName
// to return us the correct item.
//
//
// You thought the hack above was gross... This one's even
// worse. Problem: we don't think we need a miniport to boot,
// but there are some other boot.ini entries (that point to our
// partition) that do. We always want to leave existing
// boot.ini entries alone though, so we'll leave those broken.
//
// Solution: if the OSLOADPARTITION that we're translating ==
// Default, && ForceBIOSBoot is TRUE && we're translating
// the first OSLOADPARTITION (which is the one for our Default),
// then just don't call Spx86ConvertToSignatureArcName.
// This is bad because it assumes that our entry is the first,
// which it is, but it's a shakey assumption.
//
if( !_wcsicmp( BootVars[OSLOADPARTITION][i], Default ) ) { //
// This might be our Default entry. Make sure it
// really is and if so, process it the same way.
//
if( i == 0 ) { //
// It is.
//
if( ForceBIOSBoot ) {
//
// If ForceBIOSBoot is TRUE, then we want to
// force a "multi(..." string. Don't even bother calling
// Spx86ConvertToSignatureArcName on the off chance
// that we may get erroneously converted.
//
if (_wcsnicmp( BootVars[OSLOADPARTITION][i], L"scsi(", 5 ) == 0) { PWSTR MyStringPointer = NULL;
//
// Darn! We have a string that the old standard
// thought should be converted into a signature(...
// string, but we didn't write out a miniport driver.
// That can happen if someone asked us not to via
// an unattend switch.
//
// We need to change the "scsi(" to "multi("
//
MyStringPointer = SpScsiArcToMultiArc( BootVars[OSLOADPARTITION][i] );
if( MyStringPointer ) { Osloadpartition_O = SpToOem( MyStringPointer ); } else { //
// We're in trouble. Take a shot though. Just
// change the "scsi(" part to "multi(".
//
wcscpy( TemporaryBuffer, L"multi" ); wcscat( TemporaryBuffer, &BootVars[OSLOADPARTITION][i][4] );
Osloadpartition_O = SpToOem( TemporaryBuffer ); }
} else { //
// Just convert to ANSI.
//
Osloadpartition_O = SpToOem( BootVars[OSLOADPARTITION][i] );
}
} else { //
// We may need to convert this entry.
//
Osloadpartition_O = Spx86ConvertToSignatureArcName( BootVars[OSLOADPARTITION][i], DefaultSignature ); } } else { //
// This entry looks just like our Default, but it's point
// to a different installation. Just call Spx86ConvertToSignatureArcName
//
Osloadpartition_O = Spx86ConvertToSignatureArcName( BootVars[OSLOADPARTITION][i], DefaultSignature ); } } else { //
// This entry doesn't even look like our string. Send in a
// 0x0 DefaultSignature so that it will only get translated if it
// matches some entry that we know was signed in the original boot.ini.
//
Osloadpartition_O = Spx86ConvertToSignatureArcName( BootVars[OSLOADPARTITION][i], 0 ); }
//
// Insurance...
//
if (Osloadpartition_O == NULL) { Osloadpartition_O = SpToOem( BootVars[OSLOADPARTITION][i] ); }
Osloadfilename_O = SpToOem( BootVars[OSLOADFILENAME][i] ); Osloadoptions_O = SpToOem( BootVars[OSLOADOPTIONS][i] ); Loadidentifier_O = SpToOem( BootVars[LOADIDENTIFIER][i] );
sprintf( (PUCHAR)TemporaryBuffer, "%s%s%s%s %s%s", Osloadpartition_O, Osloadfilename_O, EQUALS, Loadidentifier_O, Osloadoptions_O, CRLF );
SpMemFree( Osloadpartition_O ); SpMemFree( Osloadfilename_O ); SpMemFree( Osloadoptions_O ); SpMemFree( Loadidentifier_O );
Status = ZwWriteFile( fh, NULL, NULL, NULL, &IoStatusBlock, TemporaryBuffer, strlen((PUCHAR)TemporaryBuffer) * sizeof(UCHAR), NULL, NULL );
if(!NT_SUCCESS( Status )) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Error writing %s section entry to %ws!\n", BOOTINI_OS_SECTION, BootIni)); goto cleanup; } }
//
// Finally write the old operating system line to boot.ini
// (but only if not installing on top of Win9x) and if it was
// not specifically disabled
//
if (!DiscardOldSystemLine && (WinUpgradeType != UpgradeWin95)) { Status = ZwWriteFile( fh, NULL, NULL, NULL, &IoStatusBlock, OldSystemLine, strlen(OldSystemLine) * sizeof(UCHAR), NULL, NULL );
if (!NT_SUCCESS(Status)) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Error writing %s section line to %ws!\n", BOOTINI_OS_SECTION, BootIni)); goto cleanup; } }
cleanup:
if( !NT_SUCCESS(Status) ) {
if( fh ) { ZwClose( fh ); }
} else {
//
// Set the hidden, system, readonly attributes on bootini. ignore
// error
//
RtlZeroMemory( &BasicInfo, sizeof( FILE_BASIC_INFORMATION ) ); BasicInfo.FileAttributes = FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_ARCHIVE ;
Status1 = SpSetInformationFile( fh, FileBasicInformation, sizeof(BasicInfo), &BasicInfo );
if(!NT_SUCCESS(Status1)) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unable to change attribute of %ws. Status = (%lx). Ignoring error.\n",BootIni,Status1)); }
ZwClose( fh );
}
//
// If we copied out the Default, then
// put the original copy of Default back
//
if (Default != NULL) { wcscpy(Default, _Default); }
return Status;
}
VOIDSppProcessBootIni( IN PCHAR BootIni, OUT PWSTR **BootVars, OUT PWSTR *Default, OUT PULONG Timeout )
/*++
Routine Description:
Look through the [operating systems] section and save all lines except the one for "C:\" (previous operating system) and one other optionally specified line.
Filters out the local boot line (C:\$WIN_NT$.~BT) if present.
Arguments:
Return Value:
--*/
{ PCHAR sect,s,p,n; PWSTR tmp; CHAR Key[MAX_PATH], Value[MAX_PATH], RestOfLine[MAX_PATH]; ULONG NumComponents; BOOTVAR i; ULONG DiskSignature,digval; SIGNATURED_PARTITIONS *SignedBootIniVars = &SignedBootVars;;
//
// Process the flexboot section, extract timeout and default
//
sect = SppFindSectionInBootIni(BootIni, FLEXBOOT_SECTION1); if (!sect) { sect = SppFindSectionInBootIni(BootIni, FLEXBOOT_SECTION2); } if (!sect) { sect = SppFindSectionInBootIni(BootIni, FLEXBOOT_SECTION3); } if ( sect ) { while (sect = SppNextLineInSection(sect)) { if( SppProcessLine( sect, Key, Value, RestOfLine) ) { if ( !_stricmp( Key, TIMEOUT ) ) { *Timeout = atol( Value ); } else if( !_stricmp( Key, DEFAULT ) ) { *Default = SpToUnicode( Value ); } } } }
//
// Process the operating systems section
//
sect = SppFindSectionInBootIni(BootIni,BOOTINI_OS_SECTION); if(!sect) { return; }
NumComponents = 0;
while(sect = SppNextLineInSection(sect)) { if( SppProcessLine( sect, Key, Value, RestOfLine)) { PCHAR OsLoaddir;
//
// Check if the line is the old bootloader line in which case just
// save it above, else add it to the BootVars structure
//
if (!IsNEC_98) { //NEC98
if( !_stricmp( Key, "C:\\" ) ) { sprintf( OldSystemLine, "%s=%s %s\r\n", Key, Value, RestOfLine ); } else {
//
// Ignore if local boot directory. This automatically
// filters out that directory when boot.ini is later flushed.
//
if(_strnicmp(Key,"C:\\$WIN_NT$.~BT",15) && (OsLoaddir = strchr(Key,'\\'))) { //
// Get the ARC name of the x86 system partition region.
//
PDISK_REGION SystemPartitionRegion; WCHAR SystemPartitionPath[256];
NumComponents++; for(i = FIRSTBOOTVAR; i <= LASTBOOTVAR; i++) { BootVars[i] = SpMemRealloc( BootVars[i], (NumComponents + 1) * sizeof( PWSTR * ) ); ASSERT( BootVars[i] ); BootVars[i][NumComponents] = NULL; }
SystemPartitionRegion = SpPtValidSystemPartition();#if defined(REMOTE_BOOT)
ASSERT(SystemPartitionRegion || (RemoteBootSetup && !RemoteInstallSetup));#else
ASSERT(SystemPartitionRegion);#endif // defined(REMOTE_BOOT)
if (SystemPartitionRegion) { SpArcNameFromRegion( SystemPartitionRegion, SystemPartitionPath, sizeof(SystemPartitionPath), PartitionOrdinalOriginal, PrimaryArcPath );
BootVars[OSLOADER][NumComponents - 1] = SpMemAlloc((wcslen(SystemPartitionPath)*sizeof(WCHAR))+sizeof(L"ntldr")+sizeof(WCHAR)); wcscpy(BootVars[OSLOADER][NumComponents - 1],SystemPartitionPath); SpConcatenatePaths(BootVars[OSLOADER][NumComponents - 1],L"ntldr");
BootVars[SYSTEMPARTITION][NumComponents - 1] = SpDupStringW( SystemPartitionPath ); }
BootVars[LOADIDENTIFIER][NumComponents - 1] = SpToUnicode( Value ); BootVars[OSLOADOPTIONS][NumComponents - 1] = SpToUnicode( RestOfLine );
*OsLoaddir = '\0';
//
// Now convert the signature entry into a 'multi...' entry.
//
s = strstr( Key, "signature(" ); if (s) {
s += 10; p = strchr( s, ')' ); if (p) {
//
// We've got a boot.ini entry with a 'signature' string.
// Let's save it off before we convert it into a 'multi'
// string so we can convert back easily when we're ready
// to write out the boot.ini.
//
if( SignedBootIniVars->SignedString != NULL ) { //
// We've used this entry, get another...
//
SignedBootIniVars->Next = SpMemAlloc(sizeof(SIGNATURED_PARTITIONS)); SignedBootIniVars = SignedBootIniVars->Next;
//
// Make sure...
//
SignedBootIniVars->Next = NULL; SignedBootIniVars->SignedString = NULL; SignedBootIniVars->MultiString = NULL; } SignedBootIniVars->SignedString = SpToUnicode( Key );
*p = 0; DiskSignature = 0; for (n=s; *n; n++) { if (isdigit((int)(unsigned char)*n)) { digval = *n - '0'; } else if (isxdigit((int)(unsigned char)*n)) { digval = toupper(*n) - 'A' + 10; } else { digval = 0; } DiskSignature = DiskSignature * 16 + digval; } *p = ')';
//
// !!! ISSUE : 4/27/01 : vijayj !!!
//
// Sometimes we might map a arcname to wrong region on
// disk.
//
// Although we compute a new multi(0)... style arcname
// from the nt device name, we don't have an entry in
// the map which actually maps the scsi(0)... style
// arcname to nt device name.
//
// In a multi installation scenario, if the current installation
// is on a disk which is not visible by firmware and the
// boot.ini has scsi(...) entry for this installation we
// would convert it into multi(0)... format which could be
// similar to the actual multi(0) disk. If this is the case
// and another installation exists on the first disk also
// with the same partition number and WINDOWS directory
// then we would end up using the first disk region as the
// region to upgrade and fail subsequently while trying
// to match unique IDs. User will end up with "unable to
// locate installation to upgrade message".
//
// Since the probability of all this conditions being replicated
// on different machines is very very less, currently
// I am not going to fix this.
//
//
// We've isolated the signature. Now go find a disk
// with that signature and get his ARC path.
//
for(i=0; (ULONG)i<HardDiskCount; i++) { if (HardDisks[i].Signature == DiskSignature) { tmp = SpNtToArc( HardDisks[i].DevicePath, PrimaryArcPath ); if( tmp ) { wcscpy( (PWSTR)TemporaryBuffer, tmp ); SpMemFree(tmp); p = strstr( Key, "partition(" ); if( p ) { tmp = SpToUnicode(p); if( tmp ) { wcscat( (PWSTR)TemporaryBuffer, tmp ); SpMemFree(tmp); BootVars[OSLOADPARTITION][NumComponents - 1] = SpDupStringW( (PWSTR)TemporaryBuffer ); break; } } } } } if ((ULONG)i == HardDiskCount) { BootVars[OSLOADPARTITION][NumComponents - 1] = SpToUnicode( Key ); }
//
// Save off the 'multi' entry in our list of signatures.
//
SignedBootIniVars->MultiString = SpDupStringW( BootVars[OSLOADPARTITION][NumComponents - 1] ); } } else { BootVars[OSLOADPARTITION][NumComponents - 1] = SpToUnicode( Key ); }
*OsLoaddir = '\\';#if defined(REMOTE_BOOT)
if (RemoteBootSetup && !RemoteInstallSetup) { BootVars[OSLOADFILENAME][NumComponents - 1] = SpToUnicode( strrchr(OsLoaddir,'\\') ); } else#endif // defined(REMOTE_BOOT)
{ BootVars[OSLOADFILENAME][NumComponents - 1] = SpToUnicode( OsLoaddir ); } } } } else { //NEC98
if (_strnicmp(Key,"C:\\$WIN_NT$.~BT",15) && (OsLoaddir = strchr( Key, '\\' ))) {
NumComponents++; for(i = FIRSTBOOTVAR; i <= LASTBOOTVAR; i++) { BootVars[i] = SpMemRealloc( BootVars[i], (NumComponents + 1) * sizeof( PWSTR * ) ); ASSERT( BootVars[i] ); BootVars[i][NumComponents] = NULL; }
BootVars[OSLOADER][NumComponents - 1] = SpMemAlloc(sizeof(L"ntldr")+sizeof(WCHAR)); wcscpy(BootVars[OSLOADER][NumComponents - 1],L"\\"); SpConcatenatePaths(BootVars[OSLOADER][NumComponents - 1],L"ntldr");
BootVars[SYSTEMPARTITION][NumComponents - 1] = SpToUnicode( Key );
BootVars[LOADIDENTIFIER][NumComponents - 1] = SpToUnicode( Value ); BootVars[OSLOADOPTIONS][NumComponents - 1] = SpToUnicode( RestOfLine ); *OsLoaddir = '\0'; BootVars[OSLOADPARTITION][NumComponents - 1] = SpToUnicode( Key ); *OsLoaddir = '\\'; BootVars[OSLOADFILENAME][NumComponents - 1] = SpToUnicode( OsLoaddir );
ASSERT( BootVars[OSLOADER][NumComponents - 1] ); ASSERT( BootVars[SYSTEMPARTITION][NumComponents - 1] ); ASSERT( BootVars[LOADIDENTIFIER][NumComponents - 1] ); ASSERT( BootVars[OSLOADOPTIONS][NumComponents - 1] ); ASSERT( BootVars[OSLOADPARTITION][NumComponents - 1] ); ASSERT( BootVars[OSLOADPARTITION][NumComponents - 1] ); } } //NEC98
} } return;}
PCHARSppNextLineInSection( IN PCHAR p ){ //
// Find the next \n.
//
p = strchr(p,'\n'); if(!p) { return(NULL); }
//
// skip crs, lfs, spaces, and tabs.
//
while(*p && strchr("\r\n \t",*p)) { p++; }
// detect if at end of file or section
if(!(*p) || (*p == '[')) { return(NULL); }
return(p);}
PCHARSppFindSectionInBootIni( IN PCHAR p, IN PCHAR Section ){ ULONG len = strlen(Section);
do {
//
// Skip space at front of line
//
while(*p && ((*p == ' ') || (*p == '\t'))) { p++; }
if(*p) {
//
// See if this line matches.
//
if(!_strnicmp(p,Section,len)) { return(p); }
//
// Advance to the start of the next line.
//
while(*p && (*p != '\n')) { p++; }
if(*p) { // skip nl if that terminated the loop.
p++; } } } while(*p);
return(NULL);}
BOOLEANSppProcessLine( IN PCHAR Line, IN OUT PCHAR Key, IN OUT PCHAR Value, IN OUT PCHAR RestOfLine ){ PCHAR p = Line, pLine = Line, pToken; CHAR savec; BOOLEAN Status = FALSE;
//
// Determine end of line
//
if(!p) { return( Status ); }
while( *p && (*p != '\r') && (*p != '\n') ) { p++; }
//
// back up from this position to squeeze out any whitespaces at the
// end of the line
//
while( ((p - 1) >= Line) && strchr(" \t", *(p - 1)) ) { p--; }
//
// terminate the line with null temporarily
//
savec = *p; *p = '\0';
//
// Start at beginning of line and pick out the key
//
if ( SppNextToken( pLine, &pToken, &pLine ) ) { CHAR savec1 = *pLine;
*pLine = '\0'; strcpy( Key, pToken ); *pLine = savec1;
//
// Get next token, it should be a =
//
if ( SppNextToken( pLine, &pToken, &pLine ) && *pToken == '=') {
//
// Get next token, it will be the value
//
if( SppNextToken( pLine, &pToken, &pLine ) ) { savec1 = *pLine; *pLine = '\0'; strcpy( Value, pToken ); *pLine = savec1;
//
// if another token exists then take the whole remaining line
// and make it the RestOfLine token
//
if( SppNextToken( pLine, &pToken, &pLine ) ) { strcpy( RestOfLine, pToken ); } else { *RestOfLine = '\0'; }
//
// We have a well formed line
//
Status = TRUE; } }
} *p = savec; return( Status );}
BOOLEANSppNextToken( PCHAR p, PCHAR *pBegin, PCHAR *pEnd ){ BOOLEAN Status = FALSE;
//
// Validate pointer
//
if( !p ) { return( Status ); }
//
// Skip whitespace
//
while (*p && strchr( " \t", *p ) ) { p++; }
//
// Valid tokens are "=", space delimited strings, quoted strings
//
if (*p) { *pBegin = p; if ( *p == '=' ) { *pEnd = p + 1; Status = TRUE; } else if ( *p == '\"' ) { if ( p = strchr( p + 1, '\"' ) ) { *pEnd = p + 1; Status = TRUE; } } else { while (*p && !strchr(" \t\"=", *p) ) { p++; } *pEnd = p; Status = TRUE; } } return( Status );}
//
// Boot code stuff.
//
NTSTATUSpSpBootCodeIo( IN PWSTR FilePath, IN PWSTR AdditionalFilePath, OPTIONAL IN ULONG BytesToRead, IN OUT PUCHAR *Buffer, IN ULONG OpenDisposition, IN BOOLEAN Write, IN ULONGLONG Offset, IN ULONG BytesPerSector ){ PWSTR FullPath; PUCHAR buffer = NULL; NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; UNICODE_STRING UnicodeString; OBJECT_ATTRIBUTES Obja; HANDLE Handle; LARGE_INTEGER LargeZero; PVOID UnalignedMem,AlignedBuffer;
LargeZero.QuadPart = Offset;
//
// Form the name of the file.
//
wcscpy((PWSTR)TemporaryBuffer,FilePath); if(AdditionalFilePath) { SpConcatenatePaths((PWSTR)TemporaryBuffer,AdditionalFilePath); } FullPath = SpDupStringW((PWSTR)TemporaryBuffer);
//
// Open the file.
//
INIT_OBJA(&Obja,&UnicodeString,FullPath); Status = ZwCreateFile( &Handle, Write ? FILE_GENERIC_WRITE : FILE_GENERIC_READ, &Obja, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, OpenDisposition, FILE_SYNCHRONOUS_IO_NONALERT | (Write ? FILE_WRITE_THROUGH : 0), NULL, 0 );
if(NT_SUCCESS(Status)) {
//
// Allocate a buffer if we are reading.
// Otherwise the caller passed us the buffer.
//
buffer = Write ? *Buffer : SpMemAlloc(BytesToRead);
//
// Read or write the disk -- properly aligned. Note that we force at least
// 512-byte alignment, since there's a hard-coded alignment requirement
// in the FT driver that must be satisfied.
//
if(BytesPerSector < 512) { BytesPerSector = 512; } UnalignedMem = SpMemAlloc(BytesToRead + BytesPerSector); AlignedBuffer = ALIGN(UnalignedMem,BytesPerSector);
if(Write) { RtlMoveMemory(AlignedBuffer,buffer,BytesToRead); }
Status = Write
? ZwWriteFile( Handle, NULL, NULL, NULL, &IoStatusBlock, AlignedBuffer, BytesToRead, &LargeZero, NULL ) :
ZwReadFile( Handle, NULL, NULL, NULL, &IoStatusBlock, AlignedBuffer, BytesToRead, &LargeZero, NULL );
if(NT_SUCCESS(Status)) { if(!Write) { RtlMoveMemory(buffer,AlignedBuffer,BytesToRead); } } else { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unable to %ws %u bytes from %ws (%lx)\n", Write ? L"write" : L"read", BytesToRead, FullPath, Status )); }
SpMemFree(UnalignedMem);
//
// Close the file.
//
ZwClose(Handle);
} else { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: pSpBootCodeIo: Unable to open %ws (%lx)\n",FullPath,Status)); }
SpMemFree(FullPath);
if(!Write) { if(NT_SUCCESS(Status)) { *Buffer = buffer; } else { if(buffer) { SpMemFree(buffer); } } }
return(Status);}
BOOLEANpSpScanBootcode( IN PVOID Buffer, IN PCHAR String )
/*++
Routine Description:
Look in a boot sector to find an identifying string. The scan starts at offset 128 and continues through byte 509 of the buffer. The search is case-sensitive.
Arguments:
Buffer - buffer to scan
String - string to scan for
Return Value:
--*/
{ ULONG len = strlen(String); ULONG LastFirstByte = 510 - len; ULONG i; PCHAR p = Buffer;
//
// Use the obvious brute force method.
//
for(i=128; i<LastFirstByte; i++) { if(!strncmp(p+i,String,len)) { return(TRUE); } }
return(FALSE);}
VOIDSpDetermineOsTypeFromBootSector( IN PWSTR CColonPath, IN PUCHAR BootSector, OUT PUCHAR *OsDescription, OUT PBOOLEAN IsNtBootcode, OUT PBOOLEAN IsOtherOsInstalled, IN WCHAR DriveLetter ){ PWSTR description; PWSTR *FilesToLookFor; ULONG FileCount; BOOLEAN PossiblyChicago = FALSE;
PWSTR MsDosFiles[2] = { L"MSDOS.SYS" , L"IO.SYS" };
//
// Some versions of PC-DOS have ibmio.com, others have ibmbio.com.
//
//PWSTR PcDosFiles[2] = { L"IBMDOS.COM", L"IBMIO.COM" };
PWSTR PcDosFiles[1] = { L"IBMDOS.COM" };
PWSTR Os2Files[2] = { L"OS2LDR" , L"OS2KRNL" };
//
// Check for nt boot code.
//
if(pSpScanBootcode(BootSector,"NTLDR")) {
*IsNtBootcode = TRUE; *IsOtherOsInstalled = FALSE; description = L"";
} else {
//
// It's not NT bootcode.
//
*IsNtBootcode = FALSE; *IsOtherOsInstalled = TRUE;
//
// Check for MS-DOS.
//
if (pSpScanBootcode(BootSector,((!IsNEC_98) ? "MSDOS SYS" : "IO SYS"))) { //NEC98
FilesToLookFor = MsDosFiles; FileCount = ELEMENT_COUNT(MsDosFiles); description = L"MS-DOS"; PossiblyChicago = TRUE; // Chicago uses same signature files
} else {
//
// Check for PC-DOS.
//
if(pSpScanBootcode(BootSector,"IBMDOS COM")) {
FilesToLookFor = PcDosFiles; FileCount = ELEMENT_COUNT(PcDosFiles); description = L"PC-DOS";
} else {
//
// Check for OS/2.
//
if(pSpScanBootcode(BootSector,"OS2")) {
FilesToLookFor = Os2Files; FileCount = ELEMENT_COUNT(Os2Files); description = L"OS/2";
} else { //
// Not NT, DOS, or OS/2.
// It's just plain old "previous operating system."
// Fetch the string from the resources.
//
WCHAR DriveLetterString[2];
DriveLetterString[0] = DriveLetter; DriveLetterString[1] = L'\0'; SpStringToUpper(DriveLetterString); FilesToLookFor = NULL; FileCount = 0; description = (PWSTR)TemporaryBuffer; SpFormatMessage(description,sizeof(TemporaryBuffer),SP_TEXT_PREVIOUS_OS, DriveLetterString); } } }
//
// If we think we have found an os, check to see whether
// its signature files are present.
// We could have, say, a disk where the user formats is using DOS
// and then installs NT immediately thereafter.
//
if(FilesToLookFor) {
//
// Copy CColonPath into a larger buffer, because
// SpNFilesExist wants to append a backslash onto it.
//
wcscpy((PWSTR)TemporaryBuffer,CColonPath);
if(!SpNFilesExist((PWSTR)TemporaryBuffer,FilesToLookFor,FileCount,FALSE)) {
//
// Ths os is not really there.
//
*IsOtherOsInstalled = FALSE; description = L""; } else if(PossiblyChicago) {
wcscpy((PWSTR)TemporaryBuffer, CColonPath); SpConcatenatePaths((PWSTR)TemporaryBuffer, L"IO.SYS");
if(SpHasMZHeader((PWSTR)TemporaryBuffer)) { description = L"Microsoft Windows"; } } } }
//
// convert the description to oem text.
//
*OsDescription = SpToOem(description);}
VOIDSpLayBootCode( IN OUT PDISK_REGION CColonRegion ){ PUCHAR NewBootCode; ULONG BootCodeSize; PUCHAR ExistingBootCode; NTSTATUS Status; PUCHAR ExistingBootCodeOs; PWSTR CColonPath; HANDLE PartitionHandle; PWSTR BootsectDosName = L"\\bootsect.dos"; PWSTR OldBootsectDosName = L"\\bootsect.bak"; PWSTR BootSectDosFullName, OldBootSectDosFullName, p; BOOLEAN IsNtBootcode,OtherOsInstalled, FileExist; UNICODE_STRING UnicodeString; OBJECT_ATTRIBUTES Obja; IO_STATUS_BLOCK IoStatusBlock; BOOLEAN BootSectorCorrupt = FALSE; ULONG MirrorSector; ULONG BytesPerSector; ULONGLONG ActualSectorCount, hidden_sectors, super_area_size; UCHAR SysId;
ULONGLONG HiddenSectorCount,VolumeSectorCount; //NEC98
PUCHAR DiskArraySectorData,TmpBuffer; //NEC98
ExistingBootCode = NULL; BytesPerSector = HardDisks[CColonRegion->DiskNumber].Geometry.BytesPerSector;
CLEAR_CLIENT_SCREEN(); SpDisplayStatusText(SP_STAT_INITING_FLEXBOOT,DEFAULT_STATUS_ATTRIBUTE);
switch(CColonRegion->Filesystem) {
case FilesystemNewlyCreated:
//
// If the filesystem is newly-created, then there is
// nothing to do, because there can be no previous
// operating system.
//
return;
case FilesystemNtfs:
NewBootCode = (!IsNEC_98) ? NtfsBootCode : PC98NtfsBootCode; //NEC98
BootCodeSize = (!IsNEC_98) ? sizeof(NtfsBootCode) : sizeof(PC98NtfsBootCode); //NEC98
ASSERT(BootCodeSize == 8192); break;
case FilesystemFat:
NewBootCode = (!IsNEC_98) ? FatBootCode : PC98FatBootCode; //NEC98
BootCodeSize = (!IsNEC_98) ? sizeof(FatBootCode) : sizeof(PC98FatBootCode); //NEC98
ASSERT(BootCodeSize == 512); break;
case FilesystemFat32: //
// Special hackage required for Fat32 because its NT boot code
// is discontiguous.
//
ASSERT(sizeof(Fat32BootCode) == 1536); NewBootCode = (!IsNEC_98) ? Fat32BootCode : PC98Fat32BootCode; //NEC98
BootCodeSize = 512; break;
default:
if (RepairItems[RepairBootSect]) { BootSectorCorrupt = TRUE; } else { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: bogus filesystem %u for C:!\n",CColonRegion->Filesystem)); ASSERT(0); return; } }
//
// Form the device path to C: and open the partition.
//
SpNtNameFromRegion(CColonRegion,(PWSTR)TemporaryBuffer,sizeof(TemporaryBuffer),PartitionOrdinalCurrent); CColonPath = SpDupStringW((PWSTR)TemporaryBuffer); INIT_OBJA(&Obja,&UnicodeString,CColonPath);
Status = ZwCreateFile( &PartitionHandle, FILE_GENERIC_READ | FILE_GENERIC_WRITE, &Obja, &IoStatusBlock, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ | FILE_SHARE_WRITE, FILE_OPEN, FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0 );
if (!NT_SUCCESS(Status)) { KdPrintEx ((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: unable to open the partition for C:!\n")); ASSERT(0); return; }
//
// Allocate a buffer and read in the boot sector(s) currently on the disk.
//
if (BootSectorCorrupt) {
//
// We can't determine the file system type from the boot sector, so
// we assume it's NTFS if we find a mirror sector, and FAT otherwise.
//
if (MirrorSector = NtfsMirrorBootSector (PartitionHandle, BytesPerSector, &ExistingBootCode)) {
//
// It's NTFS - use the mirror boot sector
//
NewBootCode = (!IsNEC_98) ? NtfsBootCode : PC98NtfsBootCode; //NEC98
BootCodeSize = (!IsNEC_98) ? sizeof(NtfsBootCode) : sizeof(PC98NtfsBootCode); //NEC98
ASSERT(BootCodeSize == 8192);
CColonRegion->Filesystem = FilesystemNtfs; IsNtBootcode = TRUE;
} else {
//
// It's FAT - create a new boot sector
//
NewBootCode = (!IsNEC_98) ? FatBootCode : PC98FatBootCode; //NEC98
BootCodeSize = (!IsNEC_98) ? sizeof(FatBootCode) : sizeof(PC98FatBootCode); //NEC98
ASSERT(BootCodeSize == 512);
CColonRegion->Filesystem = FilesystemFat; IsNtBootcode = FALSE;
SpPtGetSectorLayoutInformation (CColonRegion, &hidden_sectors, &ActualSectorCount);
//
// No alignment requirement here
//
ExistingBootCode = SpMemAlloc(BytesPerSector);
//
// This will actually fail with STATUS_BUFFER_TOO_SMALL but it will fill in
// the bpb, which is what we want
//
FmtFillFormatBuffer ( ActualSectorCount, BytesPerSector, HardDisks[CColonRegion->DiskNumber].Geometry.SectorsPerTrack, HardDisks[CColonRegion->DiskNumber].Geometry.TracksPerCylinder, hidden_sectors, ExistingBootCode, BytesPerSector, &super_area_size, NULL, 0, &SysId ); }
Status = STATUS_SUCCESS;
} else if ( RepairItems[RepairBootSect] && CColonRegion->Filesystem == FilesystemNtfs && (MirrorSector = NtfsMirrorBootSector (PartitionHandle, BytesPerSector, &ExistingBootCode)) ) {
//
// We use the mirror sector to repair a NTFS file system
//
} else {
//
// Just use the existing boot code.
//
Status = pSpBootCodeIo( CColonPath, NULL, BootCodeSize, &ExistingBootCode, FILE_OPEN, FALSE, 0, BytesPerSector );
if(CColonRegion->Filesystem == FilesystemNtfs) { MirrorSector = NtfsMirrorBootSector(PartitionHandle,BytesPerSector,NULL); } }
if(NT_SUCCESS(Status)) {
//
// Determine the type of operating system the existing boot sector(s) are for
// and whether that os is actually installed. Note that we don't need to call
// this for NTFS.
//
if (BootSectorCorrupt) {
OtherOsInstalled = FALSE; ExistingBootCodeOs = NULL;
} else if(CColonRegion->Filesystem != FilesystemNtfs) {
SpDetermineOsTypeFromBootSector( CColonPath, ExistingBootCode, &ExistingBootCodeOs, &IsNtBootcode, &OtherOsInstalled, CColonRegion->DriveLetter );
} else {
IsNtBootcode = TRUE; OtherOsInstalled = FALSE; ExistingBootCodeOs = NULL; }
//
// lay down the new boot code
//
if(OtherOsInstalled) {
if(RepairItems[RepairBootSect]) {
p = (PWSTR)TemporaryBuffer; wcscpy(p,CColonPath); SpConcatenatePaths(p,OldBootsectDosName); OldBootSectDosFullName = SpDupStringW(p); p = (PWSTR)TemporaryBuffer; wcscpy(p,CColonPath); SpConcatenatePaths(p,BootsectDosName); BootSectDosFullName = SpDupStringW(p);
//
// If bootsect.dos already exists, we need to delete
// bootsect.pre, which may or may not exist and
// rename the bootsect.dos to bootsect.pre.
//
FileExist = SpFileExists(BootSectDosFullName, FALSE); if (SpFileExists(OldBootSectDosFullName, FALSE) && FileExist) {
SpDeleteFile(CColonPath,OldBootsectDosName,NULL); } if (FileExist) { SpRenameFile(BootSectDosFullName, OldBootSectDosFullName, FALSE); } SpMemFree(BootSectDosFullName); SpMemFree(OldBootSectDosFullName); } else {
//
// Delete bootsect.dos in preparation for rewriting it below.
// Doing this leverages code to set its attributes in SpDeleteFile.
// (We need to remove read-only attribute before overwriting).
//
SpDeleteFile(CColonPath,BootsectDosName,NULL); }
//
// Write out the existing (old) boot sector into c:\bootsect.dos.
//
Status = pSpBootCodeIo( CColonPath, BootsectDosName, BootCodeSize, &ExistingBootCode, FILE_OVERWRITE_IF, TRUE, 0, BytesPerSector );
//
// Set the description text to the description calculated
// by SpDetermineOsTypeFromBootSector().
//
_snprintf( OldSystemLine, sizeof(OldSystemLine), "C:\\ = \"%s\"\r\n", ExistingBootCodeOs );
} // end if(OtherOsInstalled)
if(NT_SUCCESS(Status)) {
//
// Transfer the bpb from the existing boot sector into the boot code buffer
// and make sure the physical drive field is set to hard disk (0x80).
//
// The first three bytes of the NT boot code are going to be something like
// EB 3C 90, which is intel jump instruction to an offset in the boot sector,
// past the BPB, to continue execution. We want to preserve everything in the
// current boot sector up to the start of that code. Instead of harcoding
// a value, we'll use the offset of the jump instruction to determine how many
// bytes must be preserved.
//
RtlMoveMemory(NewBootCode+3,ExistingBootCode+3,NewBootCode[1]-1); if(CColonRegion->Filesystem != FilesystemFat32) { //
// On fat32 this overwrites the BigNumFatSecs field,
// a very bad thing to do indeed!
//
NewBootCode[36] = 0x80; }
//
// get Hidden sector informatin.
//
if (IsNEC_98) { //NEC98
SpPtGetSectorLayoutInformation( CColonRegion, &HiddenSectorCount, &VolumeSectorCount // not used
); //
// write Hidden sector informatin.
//
if (!RepairWinnt) { // for install a partition where before DOS 3.x
*((ULONG *)&(NewBootCode[0x1c])) = (ULONG)HiddenSectorCount; if(*((USHORT *)&(NewBootCode[0x13])) != 0) { *((ULONG *)&(NewBootCode[0x20])) = 0L; } } } //NEC98
//
// Write out boot code buffer, which now contains the valid bpb,
// to the boot sector(s).
//
Status = pSpBootCodeIo( CColonPath, NULL, BootCodeSize, &NewBootCode, FILE_OPEN, TRUE, 0, BytesPerSector );
//
// Special case for Fat32, which has a second sector of boot code
// at sector 12, discontiguous from the code on sector 0.
//
if(NT_SUCCESS(Status) && (CColonRegion->Filesystem == FilesystemFat32)) {
NewBootCode = (!IsNEC_98) ? Fat32BootCode + 1024 : PC98Fat32BootCode + 1024; //NEC98
Status = pSpBootCodeIo( CColonPath, NULL, BootCodeSize, &NewBootCode, FILE_OPEN, TRUE, 12*512, BytesPerSector ); }
//
// Update the mirror boot sector.
//
if((CColonRegion->Filesystem == FilesystemNtfs) && MirrorSector) { WriteNtfsBootSector(PartitionHandle,BytesPerSector,NewBootCode,MirrorSector); } }
if(ExistingBootCodeOs) { SpMemFree(ExistingBootCodeOs); } }
if(ExistingBootCode) { SpMemFree(ExistingBootCode); }
SpMemFree(CColonPath); ZwClose (PartitionHandle);
//
// Handle the error case.
//
if(!NT_SUCCESS(Status)) {
WCHAR DriveLetterString[2];
DriveLetterString[0] = CColonRegion->DriveLetter; DriveLetterString[1] = L'\0'; SpStringToUpper(DriveLetterString); SpStartScreen(SP_SCRN_CANT_INIT_FLEXBOOT, 3, HEADER_HEIGHT+1, FALSE, FALSE, DEFAULT_ATTRIBUTE, DriveLetterString, DriveLetterString );
SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,SP_STAT_F3_EQUALS_EXIT,0);
SpInputDrain(); while(SpInputGetKeypress() != KEY_F3) ;
SpDone(0,FALSE,TRUE); }}
#if defined(REMOTE_BOOT)
BOOLEANSpx86FlushRemoteBootVars( IN PDISK_REGION TargetRegion, IN PWSTR **BootVars, IN PWSTR Default ){ WCHAR BootIni[512]; NTSTATUS Status;
//
// Form the path to boot.ini.
//
SpNtNameFromRegion(TargetRegion,BootIni,sizeof(BootIni),PartitionOrdinalCurrent); SpConcatenatePaths(BootIni,WBOOT_INI);
//
// If Boot.ini already exists, delete it.
//
if( SpFileExists( BootIni, FALSE ) ) { SpDeleteFile( BootIni, NULL, NULL ); }
Status = Spx86WriteBootIni( BootIni, BootVars, 1, // timeout
Default, 1 // only write one line
);
if(!NT_SUCCESS( Status )) { KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Error writing boot.ini!\n")); goto cleanup; }
cleanup:
return( NT_SUCCESS(Status) );
}#endif // defined(REMOTE_BOOT)
BOOLEANSpHasMZHeader( IN PWSTR FileName ){ HANDLE FileHandle; HANDLE SectionHandle; PVOID ViewBase; ULONG FileSize; NTSTATUS Status; PUCHAR Header; BOOLEAN Ret = FALSE;
//
// Open and map the file.
//
FileHandle = 0; Status = SpOpenAndMapFile(FileName, &FileHandle, &SectionHandle, &ViewBase, &FileSize, FALSE ); if(!NT_SUCCESS(Status)) { return FALSE; }
Header = (PUCHAR)ViewBase;
//
// Guard with try/except in case we get an inpage error
//
try { if((FileSize >= 2) && (Header[0] == 'M') && (Header[1] == 'Z')) { Ret = TRUE; } } except(IN_PAGE_ERROR) { //
// Do nothing, we simply want to return FALSE.
//
}
SpUnmapFile(SectionHandle, ViewBase); ZwClose(FileHandle);
return Ret;}
//
// NEC98
//
PUCHARSpCreateBootiniImage( OUT PULONG FileSize)
{
PUCHAR BootIniBuf,IniImageBuf,IniImageBufSave,IniCreateBuf,IniCreateBufSave; PUCHAR FindSectPtr; PUCHAR sect; // point to target section. if it is NULL,not existing target section.
PUCHAR pArcNameA; WCHAR TempBuffer[256]; WCHAR TempArcPath[256]; ULONG NtDirLen,TotalNtDirlen,CreateBufCnt; ULONG Timeout; ULONG Disk; ULONG BootiniSize; ULONG ArcNameLen; PDISK_REGION pRegion; HANDLE fh; HANDLE SectionHandle; PVOID ViewBase;
#define Default_Dir "\\MOCHI"
if(!HardDiskCount){ return(NULL); } //
// Create basic style of boot.ini image and progress pointer end of line.
//
NtDirLen = TotalNtDirlen = CreateBufCnt = 0; IniCreateBufSave = IniCreateBuf = SpMemAlloc(1024); RtlZeroMemory(IniCreateBuf,1024); Timeout = DEFAULT_TIMEOUT; sprintf( IniCreateBuf, "%s%s%s%s%ld%s%s%s%s%s%s%s%s", FLEXBOOT_SECTION2, // [boot loader]
CRLF, TIMEOUT, EQUALS, Timeout, CRLF, DEFAULT, EQUALS, "c:", Default_Dir, CRLF, BOOTINI_OS_SECTION, // [operating systems]
CRLF );
sect = SppFindSectionInBootIni(IniCreateBuf,FLEXBOOT_SECTION2); if(sect == NULL){ return(NULL); } for( IniCreateBuf = sect; *IniCreateBuf && (*IniCreateBuf != '\n'); IniCreateBuf++,CreateBufCnt++); CreateBufCnt++;
sect = SppFindSectionInBootIni(IniCreateBuf,TIMEOUT); if(sect == NULL){ return(NULL); } for( IniCreateBuf = sect; *IniCreateBuf && (*IniCreateBuf != '\n'); IniCreateBuf++,CreateBufCnt++); CreateBufCnt++;
sect = SppFindSectionInBootIni(IniCreateBuf,DEFAULT); if(sect == NULL){ return(NULL); } for( IniCreateBuf = sect; *IniCreateBuf && (*IniCreateBuf != '\n'); IniCreateBuf++,CreateBufCnt++); CreateBufCnt++;
sect = SppFindSectionInBootIni(IniCreateBuf,BOOTINI_OS_SECTION); if(sect == NULL){ return(NULL); } for( IniCreateBuf = sect; *IniCreateBuf && (*IniCreateBuf != '\n'); IniCreateBuf++,CreateBufCnt++); IniCreateBuf++; CreateBufCnt++;
//
// Read boot.ini files from all drives.(except sleep and non bootable drives.)
//
for(Disk=0; Disk < HardDiskCount; Disk++){
for(pRegion=PartitionedDisks[Disk].PrimaryDiskRegions; pRegion;pRegion=pRegion->Next){
if(!pRegion->PartitionedSpace) { continue; }
SpNtNameFromRegion( pRegion, TempBuffer, sizeof(TempBuffer), PartitionOrdinalCurrent );
SpConcatenatePaths(TempBuffer,WBOOT_INI);
//
// Open and map the boot.ini file.
//
fh = 0; if(!NT_SUCCESS(SpOpenAndMapFile(TempBuffer,&fh,&SectionHandle,&ViewBase,&BootiniSize,FALSE))) { continue; }
//
// Allocate a buffer for the file.
//
IniImageBuf = SpMemAlloc(BootiniSize+1); IniImageBufSave = IniImageBuf; ASSERT(IniImageBuf); RtlZeroMemory(IniImageBuf, BootiniSize+1);
//
// Transfer boot.ini into the buffer. We do this because we also
// want to place a 0 byte at the end of the buffer to terminate
// the file.
//
// Guard the RtlMoveMemory because if we touch the memory backed by boot.ini
// and get an i/o error, the memory manager will raise an exception.
try { RtlMoveMemory(IniImageBuf,ViewBase,BootiniSize); } except( IN_PAGE_ERROR ) { //
// Do nothing, boot ini processing can proceed with whatever has been
// read
//
}
//
// check out existing target section in boot.ini
//
sect = SppFindSectionInBootIni(IniImageBuf,FLEXBOOT_SECTION2); if(sect==NULL){ SpMemFree(IniImageBufSave); SpUnmapFile(SectionHandle,ViewBase); ZwClose(fh); continue; }
sect = SppFindSectionInBootIni(IniImageBuf,DEFAULT); if(sect==NULL){ SpMemFree(IniImageBufSave); SpUnmapFile(SectionHandle,ViewBase); ZwClose(fh); continue; }
sect = SppFindSectionInBootIni(IniImageBuf,BOOTINI_OS_SECTION); if(sect == NULL){ SpUnmapFile(SectionHandle,ViewBase); ZwClose(fh); continue; }
//
// move pointer to end of line and skip the space.
//
for( IniImageBuf = sect; *IniImageBuf && (*IniImageBuf != '\n'); IniImageBuf++ ); for( ; *IniImageBuf && (( *IniImageBuf == ' ' ) || (*IniImageBuf == '\t')) ; IniImageBuf++ );
IniImageBuf++; FindSectPtr = IniImageBuf;
//
// NOTE:
// override arc name when boot path written as "C:", not as arc name.
//
ArcNameLen = 0; pArcNameA = (PUCHAR)NULL;
if( ( *(IniImageBuf+1) == L':' )&&( *(IniImageBuf+2) == L'\\' ) ) {
//
// This is NEC98 legacy style format, like "C:\WINNT=...",
// So translate to arc name for boot.ini in NT 5.0
//
SpArcNameFromRegion(pRegion, TempArcPath, sizeof(TempArcPath), PartitionOrdinalOriginal, PrimaryArcPath );
pArcNameA = SpToOem(TempArcPath);
if( pArcNameA ) { ArcNameLen = strlen(pArcNameA); IniImageBuf += 2; FindSectPtr = IniImageBuf; } }
for( NtDirLen = 0 ; *IniImageBuf && (*IniImageBuf != '\n');NtDirLen++,IniImageBuf++); NtDirLen++;
if( ArcNameLen && pArcNameA ) { // Only case of override arc path.
RtlMoveMemory( IniCreateBuf+TotalNtDirlen, pArcNameA, ArcNameLen ); TotalNtDirlen += ArcNameLen; SpMemFree(pArcNameA); }
RtlMoveMemory(IniCreateBuf+TotalNtDirlen,FindSectPtr,NtDirLen); TotalNtDirlen += NtDirLen; SpMemFree(IniImageBufSave); SpUnmapFile(SectionHandle,ViewBase); ZwClose(fh);
} }
if(TotalNtDirlen == 0){ SpMemFree(IniCreateBufSave); return(NULL); }
BootIniBuf = SpMemAlloc(CreateBufCnt + TotalNtDirlen + 1);
if(!(BootIniBuf)){ SpMemFree(IniCreateBufSave); return(NULL); }
if(FileSize) { *FileSize = CreateBufCnt + TotalNtDirlen; }
RtlZeroMemory(BootIniBuf,CreateBufCnt + TotalNtDirlen + 1); RtlMoveMemory(BootIniBuf,IniCreateBufSave,CreateBufCnt + TotalNtDirlen); BootIniBuf[CreateBufCnt + TotalNtDirlen] = 0; KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "SETUP: Create NT List\n%s\n",BootIniBuf)); SpMemFree(IniCreateBufSave); return(BootIniBuf);}
//
// NEC98
//
BOOLEANSppReInitializeBootVars_Nec98( OUT PWSTR **BootVars, OUT PWSTR *Default, OUT PULONG Timeout ){ WCHAR BootIni[512]; HANDLE FileHandle; HANDLE SectionHandle; PVOID ViewBase; NTSTATUS Status; ULONG FileSize; PUCHAR BootIniBuf; PDISK_REGION CColonRegion; BOOTVAR i; PUCHAR p; ULONG index;
PUCHAR TmpBootIniBuf; PUCHAR pBuf; PUCHAR pTmpBuf; PUCHAR pArcNameA; PUCHAR NtDir; ULONG ArcNameLen; ULONG NtDirLen; WCHAR TempArcPath[256]; BOOLEAN IsChanged = FALSE; SIZE_T Length; HEADLESS_RSP_QUERY_INFO Response;
//
// Initialize the defaults
//
for(i = FIRSTBOOTVAR; i <= LASTBOOTVAR; i++) { if(BootVars[i]){ SpMemFree(BootVars[i]); } }
for(i = FIRSTBOOTVAR; i <= LASTBOOTVAR; i++) { BootVars[i] = (PWSTR *)SpMemAlloc( sizeof ( PWSTR * ) ); ASSERT( BootVars[i] ); *BootVars[i] = NULL; }
*Default = NULL; *Timeout = DEFAULT_TIMEOUT;
//
// Just clear BOOTVARS[] when fresh setup.
//
if(NTUpgrade != UpgradeFull) return TRUE;
//
// See if there is a valid C: already. If not, then silently fail.
//
#if defined(REMOTE_BOOT)
if (RemoteBootSetup && !RemoteInstallSetup) { ASSERT(RemoteBootTargetRegion != NULL); CColonRegion = RemoteBootTargetRegion; } else#endif // defined(REMOTE_BOOT)
{ CColonRegion = TargetRegion_Nec98; }
//
// Form name of file. Boot.ini better not be on a doublespace drive.
//
ASSERT(CColonRegion->Filesystem != FilesystemDoubleSpace); SpNtNameFromRegion(CColonRegion,BootIni,sizeof(BootIni),PartitionOrdinalCurrent); SpConcatenatePaths(BootIni,WBOOT_INI);
//
// Open and map the file.
//
FileHandle = 0; Status = SpOpenAndMapFile(BootIni,&FileHandle,&SectionHandle,&ViewBase,&FileSize,FALSE); if(!NT_SUCCESS(Status)) { return TRUE; }
//
// Allocate a buffer for the file.
//
BootIniBuf = SpMemAlloc(FileSize+1); ASSERT(BootIniBuf); RtlZeroMemory(BootIniBuf, FileSize+1);
//
// Transfer boot.ini into the buffer. We do this because we also
// want to place a 0 byte at the end of the buffer to terminate
// the file.
//
// Guard the RtlMoveMemory because if we touch the memory backed by boot.ini
// and get an i/o error, the memory manager will raise an exception.
try { RtlMoveMemory(BootIniBuf,ViewBase,FileSize); } except( IN_PAGE_ERROR ) { //
// Do nothing, boot ini processing can proceed with whatever has been
// read
//
}
//
// Not needed since buffer has already been zeroed, however just do this
// just the same
//
BootIniBuf[FileSize] = 0; KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "SETUP: Create NT List\n%s\n",BootIniBuf));
//***
TmpBootIniBuf = SpMemAlloc(FileSize+256); RtlZeroMemory(TmpBootIniBuf,FileSize+256); RtlMoveMemory(TmpBootIniBuf,BootIniBuf,FileSize);
pBuf = SppFindSectionInBootIni(BootIniBuf,BOOTINI_OS_SECTION); pTmpBuf = SppFindSectionInBootIni(TmpBootIniBuf,BOOTINI_OS_SECTION);
if (pBuf && pTmpBuf) { while( *pBuf && (pBuf < BootIniBuf+FileSize-(sizeof("C:\\")-1)) ) {
if((!_strnicmp(pBuf,"C:\\",sizeof("C:\\")-1))|| (!_strnicmp(pBuf,"c:\\",sizeof("c:\\")-1))) {
ArcNameLen = 0; pArcNameA = NULL;
p = strchr(pBuf+3,'='); // *(pBuf+3) == '\\'
if((p != pBuf+3) && (*p == '=')) {
NtDirLen = (ULONG)(p - (pBuf+3)); NtDir = SpMemAlloc(NtDirLen+1); RtlZeroMemory(NtDir,NtDirLen+1); RtlMoveMemory(NtDir,pBuf+3,NtDirLen);
if(SpIsNtInDirectory(TargetRegion_Nec98,SpToUnicode(NtDir))){
SpArcNameFromRegion(TargetRegion_Nec98, TempArcPath, sizeof(TempArcPath), PartitionOrdinalOriginal, PrimaryArcPath );
if(pArcNameA=SpToOem(TempArcPath)) {
ArcNameLen = strlen(pArcNameA); RtlMoveMemory(pTmpBuf,pArcNameA,ArcNameLen); pBuf += 2; pTmpBuf += ArcNameLen;
if( !IsChanged) IsChanged = TRUE;
SpMemFree(NtDir); continue; } } SpMemFree(NtDir); } } *pTmpBuf = *pBuf; pBuf++; pTmpBuf++; } }
if (IsChanged) { if (pTmpBuf) { *pTmpBuf = 0; }
SpMemFree(BootIniBuf); BootIniBuf = TmpBootIniBuf; TmpBootIniBuf = (PUCHAR)NULL;
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_INFO_LEVEL, "SETUP: Create New NT List\n%s\n",BootIniBuf)); } else { SpMemFree(TmpBootIniBuf); TmpBootIniBuf = (PUCHAR)NULL; }
//
// Cleanup
//
SpUnmapFile(SectionHandle,ViewBase); ZwClose(FileHandle);
//
// Do the actual processing of the file.
//
SppProcessBootIni(BootIniBuf, BootVars, Default, Timeout);
//
// Scan the Buffer to see if there is a DefSwitches line,
// to move into new boot.ini in the [boot loader] section.
// If no DefSwitches, just point to a null string to be moved.
//
DefSwitches[0] = '\0'; for(p=BootIniBuf; *p && (p < BootIniBuf+FileSize-(sizeof("DefSwitches")-1)); p++) { if(!_strnicmp(p,"DefSwitches",sizeof("DefSwitches")-1)) { index = 0; while ((*p != '\r') && (*p != '\n') && *p && (index < sizeof(DefSwitches)-4)) { DefSwitches[index++] = *p++; } DefSwitches[index++] = '\r'; DefSwitches[index++] = '\n'; DefSwitches[index] = '\0'; break; } }
//
// Now add any headless parameters to the default switches.
//
Length = sizeof(HEADLESS_RSP_QUERY_INFO); Status = HeadlessDispatch(HeadlessCmdQueryInformation, NULL, 0, &Response, &Length );
if (NT_SUCCESS(Status) && (Response.PortType == HeadlessSerialPort) && Response.Serial.TerminalAttached) { if (Response.Serial.UsedBiosSettings) {
p = "redirect=UseBiosSettings\r\n";
} else {
switch (Response.Serial.TerminalPort) { case ComPort1: p = "redirect=com1\r\n"; break; case ComPort2: p = "redirect=com2\r\n"; break; case ComPort3: p = "redirect=com3\r\n"; break; case ComPort4: p = "redirect=com4\r\n"; break; default: ASSERT(0); p = NULL; break; }
}
if (p != NULL) { strcat(DefSwitches, p); }
}
SpMemFree(BootIniBuf); return( TRUE );}
//
// NEC98
//
NTSTATUSSppRestoreBootCode( VOID ){
//
// Restore previous OS boot code to boot sector from bootsect.dos.
//
WCHAR p1[256] = {0}; PUCHAR BootSectBuf; PUCHAR BootCodeBuf; HANDLE FileHandle; HANDLE SectionHandle; PVOID ViewBase; ULONG FileSize; NTSTATUS Status; PDISK_REGION SystemRegion;//
// add some code to determine bytes per sector.
//
ULONG BytesPerSector;
// BytesPerSector = HardDisks[SystemPartitionRegion->DiskNumber].Geometry.BytesPerSector;
BytesPerSector = 512; //???
wcscpy(p1,NtBootDevicePath); SpConcatenatePaths(p1,L"bootsect.dos");
FileHandle = 0; Status = SpOpenAndMapFile(p1,&FileHandle,&SectionHandle,&ViewBase,&FileSize,FALSE);
if(!NT_SUCCESS(Status)) { return(Status); }
BootCodeBuf = SpMemAlloc(FileSize+1);
try { RtlMoveMemory(BootCodeBuf,ViewBase,FileSize); } except( IN_PAGE_ERROR ) { //
// Do nothing, boot ini processing can proceed with whatever has been
// read
//
}
Status = pSpBootCodeIo( NtBootDevicePath, NULL, 2048, &BootSectBuf, FILE_OPEN, FALSE, 0, BytesPerSector );
if(!NT_SUCCESS(Status)) { SpMemFree(BootCodeBuf); SpUnmapFile(SectionHandle,ViewBase); ZwClose(FileHandle); return(Status); }
//
// Keep dirty flag in FAT BPB, to avoid confusion in disk management.
//
SystemRegion = SpRegionFromNtName(NtBootDevicePath, PartitionOrdinalCurrent); if(SystemRegion && (SystemRegion->Filesystem != FilesystemNtfs)) { BootCodeBuf[0x25] = BootSectBuf[0x25]; // Dirty flag in BPB.
}
RtlMoveMemory(BootSectBuf,BootCodeBuf,512);
pSpBootCodeIo( NtBootDevicePath, NULL, 2048, &BootSectBuf, FILE_OPEN, TRUE, 0, BytesPerSector );
SpMemFree(BootCodeBuf); SpMemFree(BootSectBuf); SpUnmapFile(SectionHandle,ViewBase); ZwClose(FileHandle); return(Status);}
|
