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

3452 lines
81 KiB
C
Raw Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1992 Microsoft Corporation
Module Name:
winnt.c
Abstract:
Top level file for DOS based NT installation program.
Author:
Ted Miller (tedm) 30-March-1992
Revision History:
--*/
/*
NOTES:
The function of this program is to pull down a complete Windows NT
installation source onto a local partition, and create a setup boot
floppy. The machine is then rebooted, starting a Windows NT Setup
just as if the user had used the real setup floppies or CD-ROM.
The following assumptions are made:
- The floppy must be provided by the user and already formatted.
- The files on the network source are in the same directory layout
structure that will be created in the temp directory on the local
source (ie, as far as winnt is concerned, the source and target
directory layout is the same).
The inf file is expected to be formatted as follows:
[SpaceRequirements]
# BootDrive is the # bytes required free on C:.
# NtDrive is the # bytes required free on the drive chosen by
# the user to contain Windows NT.
BootDrive =
NtDrive =
[Miscellaneous]
# misc junk that goes nowhere else.
[Directories]
# Specification of the source directory structure. All directories
# are relative to the directory where dos2nt.inf was found on the
# remote source or the temp directory on the local source.
# Loading and trailing backslashes are ignored -- to specify the root,
# leave the dirctory field blank or use \.
d1 =
d2 = os2
.
.
.
[Files]
# List of files to be copied to the local source directory.
# Format is <srcdir>,<filename> where <srcdir> matches an entry in the
# Directories section, and <filename> should not contain any path
# characters.
d1,ntoskrnl.exe
d1,ntdll.dll
.
.
.
[FloppyFiles]
# List of files that are to be placed on the floppy that Setup creates.
# Format is same as for lines in the [Files] sections except the directory
# is only used for the source -- the target path is always a:\.
d1,aha154x.sys
.
.
.
*/
#include "winnt.h"
#include <errno.h>
#include <string.h>
#include <dos.h>
#include <stdlib.h>
#include <direct.h>
#include <fcntl.h>
#include <ctype.h>
#include <process.h>
#if NEC_98
#include <signal.h>
#include <io.h>
#endif // NEC_98
#include "SetupSxs.h"
//
// define name of default inf file and default source path
//
#define DEFAULT_INF_NAME "dosnet.inf"
PCHAR DrvindexInfName = "drvindex.inf";
#if NEC_98
//
// Boot Device Information.(for /b)
//
typedef struct _BOOTDISKINF {
UCHAR PartitionPosition; // 0-F
UCHAR DA_UA; // SASI/IDE 80, SCSI A0
USHORT DiskSector; // Device Format Sector Size
} BOOTDISKINF, *PBOOTDISKINF;
PBOOTDISKINF BootDiskInfo; // Boot Device Information of Pointer(for /b).
BOOLEAN CursorOnFlag = FALSE; // For Cursor OFF
USHORT Cylinders; // For Dos 3.x format
UCHAR TargetDA_UA;
//
// Make File Pointer.
//
#define MAKE_FP(p,a) FP_SEG(p) = (unsigned short)((a) >> 4) & 0xffff; FP_OFF(p) = (unsigned short)((a) & 0x0f)
//
// Connect Device DA_UA.
//
typedef struct _CONNECTDAUA {
UCHAR DA_UA; // SASI/IDE 80, SCSI A0
} CONNECTDAUA, *PCONNECTDAUA;
PCONNECTDAUA DiskDAUA; // Connect DA_UA of Pointer.
PUCHAR LPTable; // DOS System of LPTable.
UCHAR SupportDosVersion = 5; // LPTable Support Dos version;
BOOLEAN SupportDos = TRUE;
#define FLOPPY_SIZE 1457664L
//
// Search First Floppy Disk Drive ( 0:None Drive / 1-26:Drive# )
//
USHORT FirstFD;
#endif // NEC_98
//
// Command line arguments
//
PCHAR CmdLineSource,CmdLineTarget,CmdLineInf,CmdLineDelete;
BOOLEAN SourceGiven,TargetGiven,InfGiven,DeleteGiven;
//
// If the user gives a script file on the command line,
// if will be appended to winnt.sif.
//
PCHAR DngScriptFile = NULL;
//
// DngSourceRootPath is the drivespec and path to the root of the source,
// and never ends in \ (will be length 2 if source is the root).
//
// Examples: D:\foo\bar D:\foo D:
//
PCHAR DngSourceRootPath;
PCHAR UserSpecifiedOEMShare = 0;
CHAR DngTargetDriveLetter;
CHAR DngSwapDriveLetter;
PVOID DngInfHandle;
PVOID DngDrvindexInfHandle;
PCHAR LocalSourceDirName = LOCAL_SOURCE_DIRECTORY;
#if NEC_98
PCHAR x86DirName = "\\NEC98";
#else // NEC_98
PCHAR x86DirName = "\\I386";
#endif // NEC_98
//
// If this flag is TRUE, then verify the files that are copied to
// the floppy. If it is FALSE, don't. The /f switch overrides.
//
BOOLEAN DngFloppyVerify = TRUE;
//
// If this is FALSE, suppress creation of the boot floppies.
//
BOOLEAN DngCreateFloppies = TRUE;
BOOLEAN DngFloppiesOnly = FALSE;
//
// If TRUE, create winnt floppies.
// If FALSE, create cd/floppy floppies (no winnt.sif)
//
BOOLEAN DngWinntFloppies = TRUE;
//
// If this flag is TRUE, then check the free space on the floppy disk
// before accepting it. Otherwise don't check free space.
//
BOOLEAN DngCheckFloppySpace = TRUE;
//
// Current drive when program invoked, saved so we can restore it
// if the user exits early.
//
unsigned DngOriginalCurrentDrive;
//
// If this is true, we do floppyless operation,
// installing an nt boot on the system partition (C:)
// and starting setup from there.
//
BOOLEAN DngFloppyless = FALSE;
//
// Unattended mode, ie, skip final reboot screen.
//
BOOLEAN DngUnattended = FALSE;
BOOLEAN DngServer = FALSE;
//
// Flag that indicates that we are running on Windows
// (ie, not bare DOS).
//
BOOLEAN DngWindows = FALSE;
//
// Flag that indicates we want to see the accessiblity options
//
BOOLEAN DngAccessibility = FALSE;
BOOLEAN DngMagnifier = FALSE;
BOOLEAN DngTalker = FALSE;
BOOLEAN DngKeyboard = FALSE;
//
// Flag for the 2nd CD enhancements to setup
//
BOOLEAN DngCopyOnlyD1TaggedFiles = TRUE;
//
// Flag that indicates that we are running OEM preinstall
//
BOOLEAN DngOemPreInstall = FALSE;
PCHAR OemSystemDirectory = WINNT_OEM_DIR;
PCHAR OemOptionalDirectory = WINNT_OEM_OPTIONAL_DIR;
PCHAR UniquenessDatabaseFile;
PCHAR UniquenessId;
//
// Command to execute at the end of GUI setup
//
PCHAR CmdToExecuteAtEndOfGui = NULL;
//
// Keep track of any optional dirs that the user wants
// to copy
//
unsigned OptionalDirCount;
CHAR *OptionalDirs[MAX_OPTIONALDIRS];
unsigned OptionalDirFlags[MAX_OPTIONALDIRS];
unsigned OptionalDirFileCount;
//
// Keep track of any OEM boot file specified on [OemBootFiles]
// in the script file
//
unsigned OemBootFilesCount;
CHAR *OemBootFiles[MAX_OEMBOOTFILES];
//
// Define the minimum disk space needed in order to copy the temporary
// directories to drives formatted with all possible cluster sizes
//
SPACE_REQUIREMENT SpaceRequirements[] = { { "TempDirSpace512", (unsigned) 512, 0 },
{ "TempDirSpace1K", (unsigned) 1024, 0 },
{ "TempDirSpace2K", (unsigned) 2048, 0 },
{ "TempDirSpace4K", (unsigned) 4096, 0 },
{ "TempDirSpace8K", (unsigned) 8192, 0 },
{ "TempDirSpace16K", (unsigned)16384, 0 },
{ "TempDirSpace32K", (unsigned)32768, 0 }
};
#define TEDM
#ifdef TEDM
BOOLEAN DngAllowNt = FALSE;
#endif
VOID
DnpFetchArguments(
VOID
);
BOOLEAN
DnpParseArguments(
IN int argc,
IN char *argv[]
);
VOID
DnpGetAccessibilityOptions(
VOID
);
VOID
DnpValidateAndConnectToShare(
FILE **InfFileHandle,
FILE **DrvindexInfFileHandle
);
VOID
DnpValidateAndInspectTarget(
VOID
);
VOID
DnpCheckMemory(
VOID
);
VOID
DnpCheckSmartdrv(
VOID
);
BOOLEAN
DnpIsValidSwapDrive(
IN CHAR Drive,
IN ULONG SpaceRequired
);
BOOLEAN
DnpIsValidLocalSource(
IN CHAR Drive,
IN BOOLEAN CheckLocalSource,
IN BOOLEAN CheckBootFiles
);
VOID
DnpDetermineLocalSourceDrive(
VOID
);
VOID
DnpDetermineSwapDrive(
VOID
);
#if 0
BOOLEAN
DnpConstructLocalSourceList(
OUT PCHAR DriveList
);
#endif
ULONG
DnGetMinimumRequiredSpace(
IN CHAR DriveLetter
);
VOID
DnpReadInf(
IN FILE *InfFileHandle,
IN FILE *DrvindexInfFileHandle
);
VOID
DnpCheckEnvironment(
VOID
);
BOOLEAN
RememberOptionalDir(
IN PCHAR Dir,
IN unsigned Flags
);
void
_far
DnInt24(
unsigned deverror,
unsigned errcode,
unsigned _far *devhdr
);
VOID
StartLog(
VOID
);
// in cpu.asm
#if NEC_98
extern
USHORT
HwGetProcessorType(
VOID
);
#else // NEC_98
USHORT
HwGetProcessorType(
VOID
);
#endif // NEC_98
#if NEC_98
VOID
CheckTargetDrive(
VOID
);
VOID
SetAutoReboot(
VOID
);
USHORT
GetSectorValue(
IN UCHAR CheckDA_UA
);
BOOLEAN
DiskSectorReadWrite(
IN USHORT HDSector,
IN UCHAR ReadWriteDA_UA,
IN BOOLEAN ReadFlag,
IN PSHORT ReadBuffer
);
VOID
GetLPTable(
IN PCHAR pLPTable
);
VOID
ClearBootFlag(
VOID
);
VOID
BootPartitionData(
VOID
);
BOOLEAN
CheckBootDosVersion(
IN UCHAR SupportDosVersion
);
VOID
GetDaUa(VOID);
VOID
SearchFirstFDD(VOID);
extern
ULONG
DnpCopyOneFile(
IN PCHAR SourceName,
IN PCHAR DestName,
IN BOOLEAN Verify
);
extern
PCHAR
DnGetSectionLineIndex (
IN PVOID INFHandle,
IN PCHAR SectionName,
IN unsigned LineIndex,
IN unsigned ValueIndex
);
VOID
DummyRoutine(
VOID
);
#endif // NEC_98
VOID
main(
IN int argc,
IN char *argv[]
)
{
FILE *f, *drvindex;
#ifdef LCP
USHORT codepage;
#endif // def LCP
#if NEC_98
DngTargetDriveLetter = 0;
//
// CTRL + C Hook
//
signal(SIGINT,DummyRoutine);
#else // NEC_98
#ifdef LCP
// Determine the local code page
_asm {
mov ax,06601h
int 21h
jnc ok
xor bx,bx
ok: mov codepage, bx
}
// If codepage does not correspond to winnt.exe's language,
// start US Winnt.exe (winntus.exe)
// Czech
#if CS
#define LANGCP (852)
#else
// Greek
#if EL
#define LANGCP (737)
#else
// Japanese
#if JAPAN
#define LANGCP (932)
#else
// Russian
#if RU
#define LANGCP (866)
#else
// Polish
#if PL
#define LANGCP (852)
#else
// Hungarian
#if HU
#define LANGCP (852)
#else
// Turkish
#if TR
#define LANGCP (857)
#else
// Pseudo
#if PSU
#define LANGCP (857)
#else
#error Unable to define LANGCP as no matching language was found.
#endif // PSU
#endif // TR
#endif // HU
#endif // PL
#endif // RU
#endif // JAPAN
#endif // EL
#endif // CS
if (codepage != LANGCP) {
argv[0] = "winntus";
execv("winntus", argv);
return;
}
#endif // def LCP
#endif // NEC_98
//
// Parse arguments
//
if(!DnpParseArguments(argc,argv)) {
PCHAR *p;
//
// Bad args. Print usage message and exit.
//
// If user specified /D, display message informing that the
// switch is no longer supported
//
for( (p = DeleteGiven ? DntUsageNoSlashD : DntUsage);
*p;
p++) {
puts(*p);
}
return;
}
//
// establish int 24 handler
//
_harderr(DnInt24);
//
// determine current drive
//
_dos_getdrive(&DngOriginalCurrentDrive);
//
// Initialize screen
//
DnInitializeDisplay();
#if NEC_98
#else
//
// Patch boot code with translated messages.
//
if(!PatchMessagesIntoBootCode()) {
DnFatalError(&DnsBootMsgsTooLarge);
}
#endif
DnWriteString(DntStandardHeader);
DnpDetermineSwapDrive ();
if(DngUnattended) {
//
// Check to see if we should process the contents of
// the script file.
// Note that we need to process the contents of the script file
// only after the video is initialized. Otherwise, we won't be able
// to report fatal errors.
//
if (DngScriptFile) {
DnpFetchArguments();
}
}
#if 0
//
// /D is no longer supported
//
if(DeleteGiven) {
DnDeleteNtTree(CmdLineDelete);
}
#endif
DnpCheckEnvironment();
#if NEC_98
LPTable = MALLOC(96,TRUE);
SupportDos = CheckBootDosVersion(SupportDosVersion);
GetLPTable(LPTable);
SearchFirstFDD();
#endif // NEC_98
DnpValidateAndConnectToShare(&f, &drvindex);
DnpReadInf(f, drvindex);
fclose(f);
fclose(drvindex);
if(DngAccessibility) {
DnpGetAccessibilityOptions();
}
DnpCheckMemory();
DnpCheckSmartdrv ();
if(!DngFloppiesOnly) {
DnpDetermineLocalSourceDrive();
}
#if NEC_98
if(!DngFloppiesOnly) {
BootDiskInfo = MALLOC(sizeof(BOOTDISKINF),TRUE);
BootPartitionData();
CheckTargetDrive();
}
#endif // NEC_98
if(!DngAllowNt && DngCreateFloppies) {
DnCreateBootFloppies();
}
if(!DngFloppiesOnly) {
DnCopyFiles();
#if NEC_98
//
// Set Auto Reboot Flag
//
if(DngFloppyless) {
ClearBootFlag();
SetAutoReboot();
}
FREE(BootDiskInfo);
FREE(LPTable);
#endif // NEC_98
DnFreeINFBuffer (DngInfHandle);
DnFreeINFBuffer (DngDrvindexInfHandle);
DnToNtSetup();
}
DnFreeINFBuffer (DngInfHandle);
DnFreeINFBuffer (DngDrvindexInfHandle);
DnExit(0);
}
BOOLEAN
RememberOptionalDir(
IN PCHAR Dir,
IN unsigned Flags
)
{
unsigned u;
for (u = 0; u < OptionalDirCount; u++) {
if(!stricmp(OptionalDirs[u],Dir)) {
OptionalDirFlags[u] = Flags;
return (TRUE);
}
}
//
// Not already in there
//
if (OptionalDirCount < MAX_OPTIONALDIRS) {
OptionalDirs[OptionalDirCount] = Dir;
OptionalDirFlags[OptionalDirCount] = Flags;
OptionalDirCount++;
return (TRUE);
}
return (FALSE);
}
BOOLEAN
RememberOemBootFile(
IN PCHAR File
)
{
unsigned u;
for (u = 0; u < OemBootFilesCount; u++) {
if(!stricmp(OemBootFiles[u],File)) {
return (TRUE);
}
}
//
// Not already in there
//
if (OemBootFilesCount < MAX_OEMBOOTFILES) {
OemBootFiles[OemBootFilesCount] = File;
OemBootFilesCount++;
return (TRUE);
}
return (FALSE);
}
VOID
DnpFetchArguments(
VOID
)
{
PCHAR WinntSetupP = WINNT_SETUPPARAMS;
PCHAR WinntYes = WINNT_A_YES;
PCHAR WinntNo = WINNT_A_NO;
FILE *FileHandle;
int Status;
PVOID ScriptHandle;
PCHAR WinntUnattended = WINNT_UNATTENDED;
PCHAR WinntOemPreinstall = WINNT_OEMPREINSTALL;
unsigned LineNumber;
//
// First open the script file as a dos file
//
FileHandle = fopen(DngScriptFile,"rt");
if(FileHandle == NULL) {
//
// fatal error.
//
DnFatalError(&DnsOpenReadScript);
}
//
// Now open it as a INF file
//
LineNumber = 0;
Status = DnInitINFBuffer (FileHandle, &ScriptHandle, &LineNumber);
fclose(FileHandle);
if(Status == ENOMEM) {
DnFatalError(&DnsOutOfMemory);
} else if(Status) {
DnFatalError(&DnsParseScriptFile, DngScriptFile, LineNumber);
}
//
// Find out if this is an OEM preinstall
//
if (DnSearchINFSection(ScriptHandle,WinntUnattended)) {
if (DnGetSectionKeyExists(ScriptHandle,WinntUnattended,WinntOemPreinstall)) {
PCHAR Ptr;
//
// OEM preinstall key exists
//
Ptr = DnGetSectionKeyIndex(ScriptHandle,WinntUnattended,WinntOemPreinstall,0);
if (Ptr != NULL) {
if (stricmp(Ptr,WinntYes) == 0) {
//
// This is an OEM pre-install
//
DngOemPreInstall = TRUE;
} else {
//
// Assume this is not an OEM pre-install
//
DngOemPreInstall = FALSE;
}
FREE (Ptr);
}
}
//
// See if the user specified a network (or any secondary) path
// for the $OEM$ files.
//
if( DngOemPreInstall ) {
if (DnGetSectionKeyExists(ScriptHandle,WinntUnattended,WINNT_OEM_DIRLOCATION)) {
PCHAR Ptr;
unsigned i;
//
// WINNT_OEM_DIRLOCATION preinstall key exists
//
Ptr = DnGetSectionKeyIndex(ScriptHandle,WinntUnattended,WINNT_OEM_DIRLOCATION,0);
//
// Now take care of the case whether or not
// the user actually appended $OEM$ onto the path.
// For the case of winnt.exe, we don't want it. We
// need to remove it if it's there.
UserSpecifiedOEMShare = DnDupString( Ptr );
FREE (Ptr);
for( i = 0; i < strlen(UserSpecifiedOEMShare); i++ ) {
UserSpecifiedOEMShare[i] = (UCHAR) toupper(UserSpecifiedOEMShare[i]);
}
Ptr = strstr( UserSpecifiedOEMShare, "$OEM$" );
if( Ptr ) {
//
// Whack the end off...
//
*Ptr = 0;
}
}
}
if( DngOemPreInstall ) {
//
// Always add to the list of optional directories the directory
// $OEM$
//
RememberOptionalDir(OemSystemDirectory, OPTDIR_OEMSYS);
//
// If this an OEM pre-install, build a list with the name of all
// OEM optional directories.
//
if (DnSearchINFSection(ScriptHandle, WINNT_OEMOPTIONAL)) {
unsigned KeyIndex;
PCHAR DirName;
//
// Add the temporary OEM directories to the array of
// temporary directories.
//
for( KeyIndex = 0;
((DirName = DnGetKeyName(ScriptHandle,WINNT_OEMOPTIONAL,KeyIndex)) != NULL );
KeyIndex++ ) {
//
// We have a valid directory name
//
PCHAR p;
if((p = DnDupString(DirName)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
RememberOptionalDir(p, OPTDIR_OEMOPT);
FREE (DirName);
}
}
//
// If this an OEM pre-install, build a list with the name of all
// OEM boot files.
//
if (DnSearchINFSection(ScriptHandle, WINNT_OEMBOOTFILES)) {
unsigned LineIndex;
PCHAR FileName;
//
// Add the OEM boot files to the array of
// OEM boot files.
//
for( LineIndex = 0;
((FileName = DnGetSectionLineIndex(ScriptHandle,WINNT_OEMBOOTFILES,LineIndex,0)) != NULL );
LineIndex++ ) {
PCHAR q;
if((q = DnDupString(FileName)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
RememberOemBootFile(q);
FREE (FileName);
}
}
}
}
//
// We are done with the ScriptHandle for now
//
DnFreeINFBuffer(ScriptHandle);
}
BOOLEAN
DnpParseArguments(
IN int argc,
IN char *argv[]
)
/*++
Routine Description:
Parse arguments passed to the program. Perform syntactic validation
and fill in defaults where necessary.
Valid arguments:
/d:path - specify installation to remove
(not supported anymore)
/s:sharepoint[path] - specify source sharepoint and path on it
/t:drive[:] - specify temporary local source drive
/i:filename - specify name of inf file
/o - create boot floppies only
(not supported anymore)
/f - turn floppy verification off
(not supported anymore)
/c - suppress free-space check on the floppy
(not supported anymore)
/x - suppress creation of the floppy altogether
/b - floppyless operation
(not supported anymore)
/u - unattended (skip final reboot screen)
/w - [undoc'ed] must be specifed when running
under windows, chicago, etc.
/a - enable accessibility options
/2 - copy the entire source locally - all files irrespective
of the d1/d2 tags. Default is only d1 tagged files.
Introduced for the 2 CD install that is required tablets.
Arguments:
argc - # arguments
argv - array of pointers to arguments
Return Value:
None.
--*/
{
PCHAR arg;
CHAR swit;
PCHAR ArgSwitches[] = { "E", "D", "T", "I", "RX", "R", "S", NULL };
PCHAR RestOfSwitch;
int i;
int l;
//
// Set the variables that are no longer
// settable via the command line.
//
DngFloppyless = TRUE;
DngCreateFloppies = FALSE;
//
// Skip program name
//
argv++;
DeleteGiven = SourceGiven = TargetGiven = FALSE;
OptionalDirCount = 0;
CmdLineTarget = CmdLineInf = NULL;
while(--argc) {
if((**argv == '-') || (**argv == '/')) {
swit = argv[0][1];
//
// Process switches that take no arguments here.
//
switch(swit) {
case '?':
return(FALSE); // force usage
#if 0
case 'f':
case 'F':
argv++;
DngFloppyVerify = FALSE;
continue;
#endif
#if 0
case 'c':
case 'C':
argv++;
DngCheckFloppySpace = FALSE;
continue;
#endif
#if 0
case 'x':
case 'X':
argv++;
DngCreateFloppies = FALSE;
continue;
#endif
#ifdef LOGGING
case 'l':
case 'L':
argv++;
StartLog();
continue;
#endif
#if 0
case 'o':
case 'O':
//
// check for /Ox. /O* is a secret switch that replaces the old /o.
//
switch(argv[0][2]) {
case 'x':
case 'X':
DngWinntFloppies = FALSE;
case '*':
break;
default:
return(FALSE);
}
argv++;
DngFloppiesOnly = TRUE;
continue;
#endif
#if 0
case 'b':
case 'B':
argv++;
DngFloppyless = TRUE;
continue;
#endif
case 'u':
case 'U':
if(((argv[0][2] == 'd') || (argv[0][2] == 'D'))
&& ((argv[0][3] == 'f') || (argv[0][3] == 'F'))) {
if((argv[0][4] == ':') && argv[0][5]) {
if((arg = strchr(&argv[0][5],',')) == NULL) {
arg = strchr(&argv[0][5],0);
}
l = arg - &argv[0][5];
UniquenessId = MALLOC(l+2,TRUE);
memcpy(UniquenessId,&argv[0][5],l);
UniquenessId[l] = 0;
if(*arg++) {
if(*arg) {
//
// Now the rest of the param is the filename of
// the uniqueness database
//
UniquenessDatabaseFile = DnDupString(arg);
UniquenessId[l] = '*';
UniquenessId[l+1] = 0;
} else {
return(FALSE);
}
}
} else {
return(FALSE);
}
} else {
DngUnattended = TRUE;
//
// User can say -u:<file> also
//
if(argv[0][2] == ':') {
if(argv[0][3] == 0) {
return(FALSE);
}
if((DngScriptFile = DnDupString(&argv[0][3])) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
}
}
argv++;
continue;
case 'w':
case 'W':
//
// This flag used to force us to run under Windows,
// when doing a 386 stepping check could crash the system.
// Now we don't support 386, so this check is never done.
//
// However we accept the arg to force us into Windows mode on DOS,
// which allows someone to avoid the final reboot.
//
DngWindows = TRUE;
argv++;
continue;
case 'a':
case 'A':
argv++;
DngAccessibility = TRUE;
continue;
#ifdef TEDM
case 'i':
case 'I':
if(!stricmp(argv[0]+1,"I_am_TedM")) {
argv++;
DngAllowNt = TRUE;
continue;
}
#endif
case '2':
argv++;
DngCopyOnlyD1TaggedFiles = FALSE;
//_LOG(("Going to copy files irrespective of the directory tag\n"));
continue;
}
//
// Process switches that take arguments here.
//
//
// This code taken from winnt32.c. It has the
// purpose of validating the switch and determining
// where the next argument lines
//
for (i=0; ArgSwitches[i]; i++) {
l = strlen(ArgSwitches[i]);
if (!strnicmp(ArgSwitches[i],&argv[0][1],l)) {
//
// we have a match. Next char of arg must either
// be : or nul. If it's : then arg immediately
// follows. Otherwise, if it's null, then arg must
// be next argument
//
if (argv[0][1+l] == ':') {
arg = &argv[0][2+l];
if (*arg == '\0') {
return (FALSE);
}
RestOfSwitch = &argv[0][2];
break;
} else {
if (argv[0][1+l] == '\0') {
if (argc <= 1) {
//
// no arguments left
//
return (FALSE);
}
RestOfSwitch = &argv[0][2];
argc--;
arg = argv[1];
argv++;
break;
} else {
//
// Do nothing here
//
NULL;
} // if ... else
} // if ... else
} // if ...
} // for
//
// Check termination condition
//
if (!ArgSwitches[i]) {
return (FALSE);
}
switch(swit) {
case 'r':
case 'R':
RememberOptionalDir(
DnDupString(arg),
( (RestOfSwitch[0] == 'X' || RestOfSwitch[0] == 'x') ?
OPTDIR_TEMPONLY : 0 ) );
break;
case 'd':
case 'D':
//
// /D is no longer supported
//
DeleteGiven = TRUE;
return(FALSE);
#if 0
case 'd':
case 'D':
if(DeleteGiven) {
return(FALSE);
} else {
if((CmdLineDelete = DnDupString(arg)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
DeleteGiven = TRUE;
}
break;
#endif
case 's':
case 'S':
if(SourceGiven) {
return(FALSE);
} else {
if((CmdLineSource = DnDupString(arg)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
SourceGiven = TRUE;
}
break;
case 't':
case 'T':
if(TargetGiven) {
return(FALSE);
} else {
if((CmdLineTarget = DnDupString(arg)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
TargetGiven = TRUE;
}
break;
case 'i':
case 'I':
if(InfGiven) {
return(FALSE);
} else {
if((CmdLineInf = DnDupString(arg)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
InfGiven = TRUE;
}
break;
case 'E':
case 'e':
if(CmdToExecuteAtEndOfGui) {
return(FALSE);
} else {
if((CmdToExecuteAtEndOfGui = DnDupString(arg)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
}
break;
default:
return(FALSE);
}
} else {
return(FALSE);
}
argv++;
}
//
// If /u was specified, make sure /s was also given
// and force /b.
//
if(DngUnattended) {
if(!SourceGiven) {
return(FALSE);
}
DngFloppyless = TRUE;
}
if(DngFloppyless) {
//
// Force us into the floppy creation code.
//
DngCreateFloppies = TRUE;
DngWinntFloppies = TRUE;
}
return(TRUE);
}
VOID
DnpGetAccessibilityOptions(
VOID
)
/*++
Routine Description:
Ask the user which accessibility utilities to install for GUI Setup.
Arguments:
None.
Return Value:
None.
--*/
{
ULONG ValidKey[4];
ULONG Key;
CHAR Mark;
//
// Make sure the setup boot floppy we created is in the drive
// if necessary.
//
DnClearClientArea();
DnDisplayScreen(&DnsAccessibilityOptions);
DnWriteStatusText(DntEnterEqualsContinue);
ValidKey[0] = ASCI_CR;
ValidKey[1] = DN_KEY_F1;
ValidKey[2] = DN_KEY_F2;
ValidKey[3] = 0;
while((Key = DnGetValidKey(ValidKey)) != ASCI_CR) {
switch(Key) {
case DN_KEY_F1:
DngMagnifier = (BOOLEAN)!DngMagnifier;
Mark = DngMagnifier ? RADIO_ON : RADIO_OFF;
DnPositionCursor(4,7);
break;
case DN_KEY_F2:
DngTalker = (BOOLEAN)!DngTalker;
Mark = DngTalker ? RADIO_ON : RADIO_OFF;
DnPositionCursor(4,8);
break;
#if 0
case DN_KEY_F3:
DngKeyboard = (BOOLEAN)!DngKeyboard;
Mark = DngKeyboard ? RADIO_ON : RADIO_OFF;
DnPositionCursor(4,9);
break;
#endif
}
DnWriteChar(Mark);
}
}
VOID
DnpValidateAndConnectToShare(
FILE **InfFileHandle,
FILE **DrvindexInfFileHandle
)
/*++
Routine Description:
Split the source given by the user into drive and path
components. If the user did not specify a source, prompt him
for one. Look for dos2nt.inf on the source (ie, validate the
source) and keep prompting the user for a share until he enters
one which appears to be valid.
Arguments:
Return Value:
None.
--*/
{
CHAR UserString[256];
PCHAR InfFullName, DrvindexInfFullName;
PCHAR q;
BOOLEAN ValidSourcePath;
unsigned len;
DnClearClientArea();
DnWriteStatusText(NULL);
//
// Use default inf file if none specified.
//
if(!InfGiven) {
CmdLineInf = DEFAULT_INF_NAME;
}
//
// If the user did not enter a source, prompt him for one.
//
if(SourceGiven) {
strcpy(UserString,CmdLineSource);
} else {
#if NEC_98
CursorOnFlag = TRUE;
#endif // NEC_98
DnDisplayScreen(&DnsNoShareGiven);
DnWriteStatusText("%s %s",DntEnterEqualsContinue,DntF3EqualsExit);
if(getcwd(UserString,sizeof(UserString)-1) == NULL) {
UserString[0] = '\0';
}
#if NEC_98
CursorOnFlag = FALSE;
#endif // NEC_98
DnGetString(UserString,NO_SHARE_X,NO_SHARE_Y,NO_SHARE_W);
}
ValidSourcePath = FALSE;
do {
DnWriteStatusText(DntOpeningInfFile);
//
// Make a copy of the path the user typed leaving extra room.
//
DngSourceRootPath = MALLOC(256,TRUE);
if(len = strlen(UserString)) {
strcpy(DngSourceRootPath,UserString);
//
// If the user typed something like x:, then we want to
// change that to x:. so this does what he expects.
// Doing so also lets the canonicalize routine work.
//
if((DngSourceRootPath[1] == ':') && !DngSourceRootPath[2]) {
DngSourceRootPath[2] = '.';
DngSourceRootPath[3] = 0;
}
//
// Now attempt to canonicalize the name. If this doesn't work,
// then it's definitely not a valid path.
//
if(DnCanonicalizePath(DngSourceRootPath,UserString)) {
strcpy(DngSourceRootPath,UserString);
//
// If the path doesn't end with a backslash,
// append a backslash before appending the inf filename.
//
len = strlen(DngSourceRootPath);
if(DngSourceRootPath[len-1] != '\\') {
DngSourceRootPath[len] = '\\';
DngSourceRootPath[len+1] = 0;
len++;
}
InfFullName = MALLOC(len + strlen(CmdLineInf) + 1,TRUE);
strcpy(InfFullName,DngSourceRootPath);
strcat(InfFullName,CmdLineInf);
DrvindexInfFullName = MALLOC(len + strlen(DrvindexInfName) + 1,TRUE);
strcpy(DrvindexInfFullName,DngSourceRootPath);
strcat(DrvindexInfFullName,DrvindexInfName);
//
// Attempt to open the inf file on the source.
// If that fails look for it in the i386 subdirectory.
//
//_LOG(("Validate source path: trying %s\n",InfFullName));
//_LOG(("Validate source path: trying %s\n",DrvindexInfFullName));
if((*InfFileHandle = fopen(InfFullName,"rt")) != NULL){
if((*DrvindexInfFileHandle = fopen(DrvindexInfFullName,"rt")) != NULL){
ValidSourcePath = TRUE;
}
else
fclose( *InfFileHandle );
}
if(*InfFileHandle != NULL ){
//_LOG(("%s opened successfully\n",InfFullName));
}
if(*DrvindexInfFileHandle != NULL ){
//_LOG(("%s opened successfully\n",DrvindexInfFullName));
}
FREE(InfFullName);
FREE(DrvindexInfFullName);
if(!ValidSourcePath) {
InfFullName = MALLOC(len+strlen(CmdLineInf)+strlen(x86DirName)+1,TRUE);
DrvindexInfFullName = MALLOC(len+strlen(DrvindexInfName)+strlen(x86DirName)+1,TRUE);
strcpy(InfFullName,DngSourceRootPath);
strcat(InfFullName,x86DirName+1);
strcat(InfFullName,"\\");
strcpy(DrvindexInfFullName, InfFullName);
strcat(InfFullName,CmdLineInf);
strcat(DrvindexInfFullName,DrvindexInfName);
//_LOG(("Validate source path: trying %s\n",InfFullName));
if((*InfFileHandle = fopen(InfFullName,"rt")) != NULL){
if((*DrvindexInfFileHandle = fopen(DrvindexInfFullName,"rt")) != NULL){
ValidSourcePath = TRUE;
}
else
fclose( *InfFileHandle );
}
if(*InfFileHandle != NULL ){
//_LOG(("%s opened successfully\n",InfFullName));
}
if(*DrvindexInfFileHandle != NULL ){
//_LOG(("%s opened successfully\n",DrvindexInfFullName));
}
FREE(InfFullName);
FREE(DrvindexInfFullName);
if(ValidSourcePath) {
//
// Change the source to the i386 subdirectory.
//
q = DngSourceRootPath;
DngSourceRootPath = MALLOC(strlen(q)+strlen(x86DirName),TRUE);
strcpy(DngSourceRootPath,q);
strcat(DngSourceRootPath,x86DirName+1);
FREE(q);
}
}
}
}
if(!ValidSourcePath) {
FREE(DngSourceRootPath);
DnClearClientArea();
#if NEC_98
CursorOnFlag = TRUE;
#endif // NEC_98
DnDisplayScreen(&DnsBadSource);
DnWriteStatusText("%s %s",DntEnterEqualsContinue,DntF3EqualsExit);
#if NEC_98
CursorOnFlag = FALSE;
#endif // NEC_98
DnGetString(UserString,NO_SHARE_X,BAD_SHARE_Y,NO_SHARE_W);
}
} while(!ValidSourcePath);
//
// Make sure DngSourceRootPath does not end with a backslash.
// and trim the buffer down to size.
//
len = strlen(DngSourceRootPath);
if(DngSourceRootPath[len-1] == '\\') {
DngSourceRootPath[len-1] = 0;
}
if(q = DnDupString(DngSourceRootPath)) {
FREE(DngSourceRootPath);
DngSourceRootPath = q;
}
//_LOG(("Source root path is %s\n",DngSourceRootPath));
}
VOID
DnRemoveTrailingSlashes(
PCHAR Path
)
{
if (Path != NULL && Path[0] != 0) {
int Length = strlen(Path);
while (Path[Length - 1] == '\\' || Path[Length - 1] == '/') {
Length -= 1;
}
Path[Length] = 0;
}
}
VOID
DnRemoveLastPathElement(
PCHAR Path
)
{
PCHAR LastBackSlash = strrchr(Path, '\\');
if (LastBackSlash != NULL) {
*(LastBackSlash + 1) = 0;
}
}
VOID
DnpReadInf(
IN FILE *InfFileHandle,
IN FILE *DrvindexInfFileHandle
)
/*++
Routine Description:
Read the INF file. Does not return if error.
Arguments:
None.
Return Value:
None.
--*/
{
int Status;
PCHAR p;
PCHAR pchHeader;
unsigned LineNumber, DLineNumber;
DnWriteStatusText(DntReadingInf,CmdLineInf);
DnClearClientArea();
LineNumber = 0;
Status = DnInitINFBuffer (InfFileHandle, &DngInfHandle, &LineNumber);
if(Status == ENOMEM) {
DnFatalError(&DnsOutOfMemory);
} else if(Status) {
DnFatalError(&DnsBadInf);
}
DLineNumber = 0;
Status = DnInitINFBuffer (DrvindexInfFileHandle, &DngDrvindexInfHandle, &DLineNumber);
if(Status == ENOMEM) {
DnFatalError(&DnsOutOfMemory);
} else if(Status) {
DnFatalError(&DnsBadInf);
}
//
// Determine product type (workstation/server)
//
p = DnGetSectionKeyIndex(DngInfHandle,DnfMiscellaneous,"ProductType",0);
pchHeader = DntWorkstationHeader; // default to workstation
if(p && atoi(p)) {
switch(atoi(p)) {
case 4:
pchHeader = DntPersonalHeader;
break;
case 1: //server
case 2: //enterprise
case 3: //datacenter
default:
pchHeader = DntServerHeader;
DngServer = TRUE;
break;
}
}
if (p) {
FREE (p);
}
DnPositionCursor(0,0);
DnWriteString(pchHeader);
//
// Get mandatory optional components
//
LineNumber = 0;
while(p = DnGetSectionLineIndex(DngInfHandle,"OptionalSrcDirs",LineNumber++,0)) {
PCHAR q;
if((q = DnDupString(p)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
RememberOptionalDir(q, OPTDIR_TEMPONLY);
FREE (p);
}
//
// get Fusion Side By Side Assemblies ("sxs_" here for searching)
//
{
struct find_t FindData;
unsigned InfSectionLineNumber = 0;
PCHAR InfValue;
unsigned optdirFlags;
CHAR SourceDir[DOS_MAX_PATH];
PCHAR DupInfValue;
PCHAR FreeInfValue;
while(InfValue = DnGetSectionLineIndex(DngInfHandle, DnfAssemblyDirectories, InfSectionLineNumber++, 0)) {
//
// convention introduced specifically for side by side, so that
// x86 files on ia64 might come from \i386\asms instead of \ia64\asms\i386,
// depending on what dosnet.inf and syssetup.inf say:
// a path that does not start with a slash is appended to \$win_nt$.~ls\processor;
// a path that does start with a slash is appended to \$win_nt$.~ls
//
// We honor it in x86-only winnt.exe in case anyone decides to use it
// for other reasons, to keep parity in this area between winnt and winnt32.exe.
optdirFlags = OPTDIR_TEMPONLY;
strcpy(SourceDir, DngSourceRootPath); // includes trailing i386
FreeInfValue = InfValue;
if (InfValue[0] == '\\' || InfValue[0] == '/') {
optdirFlags |= OPTDIR_PLATFORM_INDEP;
// remove trailing i386
DnRemoveTrailingSlashes(SourceDir);
DnRemoveLastPathElement(SourceDir);
// remove leading slash
InfValue += 1;
}
DnpConcatPaths(SourceDir, InfValue);
//
// The asms directory is optional because there might just be asms*.cab.
//
if (_dos_findfirst(SourceDir, _A_HIDDEN|_A_SYSTEM|_A_SUBDIR, &FindData) == 0
&& (FindData.attrib & _A_SUBDIR)) {
if((DupInfValue = DnDupString(InfValue)) == NULL) {
DnFatalError(&DnsOutOfMemory);
}
RememberOptionalDir(DupInfValue, optdirFlags);
FREE(FreeInfValue);
}
}
}
}
VOID
DnpCheckEnvironment(
VOID
)
/*++
Routine Description:
Verify that the following are true:
- DOS major version 5 or greater
- there is a floppy drive at a: that is 1.2 meg or greater
If any of the above are not true, abort with a fatal error.
Arguments:
None.
Return Value:
None.
--*/
{
UCHAR DeviceParams[256];
unsigned char _near * pDeviceParams = DeviceParams;
DnWriteStatusText(DntInspectingComputer);
DeviceParams[0] = 0; // get default device params
_asm {
//
// Check if we're on NT.
// The true version on NT is 5.50.
//
mov ax,3306h
sub bx,bx
int 21h
cmp bx,3205h // check for v. 5.50
jne checkwin
#ifdef TEDM
cmp DngAllowNt,1
je checkflop
#endif
bados:
push seg DnsCantRunOnNt
push offset DnsCantRunOnNt
call DnFatalError // doesn't return
checkwin:
//
// The /w switch used to be necessary since we could crash Windows
// checking the CPU stepping on a 386. However since we don't support
// 386 any more, we never do that check and we can simply detect
// whether we're on Windows. The /w switch is not necessary.
//
mov ax,1600h
int 2fh
test al,7fh
jz checkcpu
mov DngWindows,1
//
// Now check Win95. Issue int2f func 4a33.
// If ax comes back as 0 then it's win95.
//
push ds
push si
push dx
push bx
mov ax,4a33h
int 2fh
pop bx
pop dx
pop si
pop ds
cmp ax,0
jz bados
checkcpu:
//
// Check CPU type. Fail if not greater than 386.
//
call HwGetProcessorType
cmp ax,3
ja checkflop
push seg DnsRequires486
push offset DnsRequires486
call DnFatalError // doesn't return
checkflop:
//
// If this is not a floppyless installation, check for 1.2MB
// or greater A:. Get the default device params for drive A:
// and check the device type field.
//
#if NEC_98
#else // NEC_98
cmp DngFloppyless,1 // floppyless installation?
je checkdosver // yes, no floppy drive required
mov ax,440dh // ioctl
mov bl,1 // drive a:
mov cx,860h // category disk, func get params
mov dx,pDeviceParams // ds is already correct
int 21h
jnc gotdevparams
flopperr:
push seg DnsRequiresFloppy
push offset DnsRequiresFloppy
call DnFatalError // doesn't return
gotdevparams:
//
// Check to make sure that the device is removable and perform
// checks on the media type
//
mov si,pDeviceParams
test [si+2],1 // bit 0 clear if removable
jnz flopperr
#ifdef ALLOW_525
cmp [si+1],1 // media type = 1.2meg floppy?
jz checkdosver
#endif
cmp [si+1],7 // media type = 1.4meg floppy
jb flopperr // or greater?
checkdosver:
#endif // NEC_98
//
// Check DOS version >= 5.0
//
mov ax,3000h // function 30h -- get DOS version
int 21h
cmp al,5
jae checkdone // >= 5.0
//
// version < 5
//
push seg DnsBadDosVersion
push offset DnsBadDosVersion
call DnFatalError
checkdone:
}
}
VOID
DnpCheckMemory(
VOID
)
/*++
Routine Description:
Verify that enough memory is installed in the machine.
Arguments:
None.
Return Value:
None. Does not return in there's not enough memory.
--*/
{
USHORT MemoryK;
ULONG TotalMemory,RequiredMemory;
PCHAR RequiredMemoryStr;
//
// Now that servers require so much memory (64Mb), just remove this check.
// We'll catch him in textmode.
// -matth
//
return;
DnWriteStatusText(DntInspectingComputer);
//
// I cannot figure out a reliable way to determine the amount of
// memory in the machine. Int 15 func 88 is likely to be hooked by
// himem.sys or some other memory manager to return 0. DOS maintains
// the original amount of extended memory but to get to this value
// you have to execute the sysvars undocumented int21 ah=52 call, and
// even then what about versions previous to dos 4? Calling himem to
// ask for the total amount of xms memory does not give you the total
// amount of extended memory, just the amount of xms memory.
// So we'll short-circuit the memory check code by always deciding that
// there's 50MB of extended memory. This should always be big enough,
// and this way the rest of the code stays intact, ready to work if
// we figure out a way to make the memory determination. Just replace
// the following line with the check, and make sure MemoryK is set to
// the amount of extended memory in K.
//
// Update: one might be able to get the amount of extended memory by
// looking in CMOS. See the code below.
// The only problem with this is that it cannot detect more than 63MB
// of extended memory. This should be good for now, since this is
// enough even for NT server.
//
_asm {
//
// This code access to I/O ports 70H and 71H.
// But these port are different feature on NEC98.
// The 70H port is Character Display controller's port.
// So, if this code running(out 70h, 18h) on NEC98, display
// setting will be broken and garbage characters displayed.
//
#if NEC_98
push ax
push es
mov ax, 40h
mov es, ax
xor ax, ax
mov al, es:[1] // 1M - 16M memories(per 128K)
shr ax, 3 // convert MB
add ax, es:[194h] // Over 16M memories(per 1M)
mov MemoryK,ax
pop es
pop ax
#else // NEC_98
push ax
cli
mov al, 18h // get extended memory high
out 70h, al
jmp short $+2
in al, 71H
shl ax, 08H
mov al, 17H // get extended memory low
out 70H, al
jmp short $+2
in al, 71H
mov MemoryK,ax
sti
pop ax
#endif // NEC_98
}
//
// Account for conventional memory. Simplistic, but good enough.
//
#if NEC_98
MemoryK *= 1024;
MemoryK += 640;
#else // NEC_98
MemoryK += 1024;
#endif // NEC_98
TotalMemory = (ULONG)MemoryK * 1024L;
RequiredMemoryStr = DnGetSectionKeyIndex( DngInfHandle,
DnfMiscellaneous,
DnkMinimumMemory,
0
);
//
// If the required memory is not specified in the inf, force an error
// to get someone's attention so we can fix dosnet.inf.
//
RequiredMemory = RequiredMemoryStr ? (ULONG)atol(RequiredMemoryStr) : 0xffffffff;
if (RequiredMemoryStr) {
FREE (RequiredMemoryStr);
}
if(TotalMemory < RequiredMemory) {
CHAR Decimal[10];
ULONG r;
CHAR Line1[100],Line2[100];
r = ((RequiredMemory % (1024L*1024L)) * 100L) / (1024L*1024L);
if(r) {
sprintf(Decimal,".%lu",r);
} else {
Decimal[0] = 0;
}
snprintf(Line1,sizeof(Line1),DnsNotEnoughMemory.Strings[NOMEM_LINE1],RequiredMemory/(1024L*1024L),Decimal);
DnsNotEnoughMemory.Strings[NOMEM_LINE1] = Line1;
r = ((TotalMemory % (1024L*1024L)) * 100L) / (1024L*1024L);
if(r) {
sprintf(Decimal,".%lu",r);
} else {
Decimal[0] = 0;
}
snprintf(Line2,sizeof(Line2),DnsNotEnoughMemory.Strings[NOMEM_LINE2],TotalMemory/(1024L*1024L),Decimal);
DnsNotEnoughMemory.Strings[NOMEM_LINE2] = Line2;
DnFatalError(&DnsNotEnoughMemory);
}
}
VOID
DnpCheckSmartdrv(
VOID
)
/*++
Routine Description:
Verify that SMARTDRV is installed in the machine.
Arguments:
None.
Return Value:
None. If SMARTDRV is not installed we recommend the user to install it.
They have a chance to quit setup or to go on without SMARTDRV.
--*/
{
ULONG ValidKey[3];
ULONG c;
USHORT sinst = 0;
if (!DngUnattended) {
_asm {
push ax
push bx
push cx
push dx
push di
push si
push bp
mov ax, 4a10h
xor bx, bx
mov cx, 0ebabh
int 2fh
cmp ax, 0babeh
jne final
pop bp
mov sinst, 1
push bp
final:
pop bp
pop si
pop di
pop dx
pop cx
pop bx
pop ax
}
if (!sinst) {
ValidKey[0] = ASCI_CR;
ValidKey[1] = DN_KEY_F3;
ValidKey[2] = 0;
DnClearClientArea();
DnDisplayScreen(&DnsNoSmartdrv);
DnWriteStatusText("%s %s",DntEnterEqualsContinue,DntF3EqualsExit);
while(1) {
c = DnGetValidKey(ValidKey);
if(c == ASCI_CR) {
break;
}
if(c == DN_KEY_F3) {
DnExitDialog();
}
}
DnClearClientArea();
}
}
}
void
_far
DnInt24(
unsigned deverror,
unsigned errcode,
unsigned _far *devhdr
)
/*++
Routine Description:
Int24 handler. We do not perform any special actions on a hard error;
rather we just return FAIL so the caller of the failing api will get
back an error code and take appropriate action itself.
This function should never be invoked directly.
Arguments:
deverror - supplies the device error code.
errcode - the DI register passed by MS-DOS to int 24 handlers.
devhdr - supplies pointer to the device header for the device on which
the hard error occured.
Return Value:
None.
--*/
{
_hardresume(_HARDERR_FAIL);
}
VOID
DnpDetermineSwapDrive(
VOID
)
/*++
Routine Description:
Determine the swap drive. We need to be able to write on that drive and
we need at least 500K free disk space.
Arguments:
None.
Return Value:
None. Sets the global variable DngSwapDriveLetter.
--*/
{
ULONG CheckingDrive;
CHAR SystemPartitionDriveLetter, TheDrive, DriveLetter;
DngSwapDriveLetter = '?';
#if NEC_98
SystemPartitionDriveLetter = 'A';
#else
SystemPartitionDriveLetter = 'C';
#endif
TheDrive = 0;
for( CheckingDrive = SystemPartitionDriveLetter - 'A'; CheckingDrive < ('Z' - 'A'); CheckingDrive++ ) {
DriveLetter = (CHAR)('A' + CheckingDrive);
if (DnpIsValidSwapDrive (DriveLetter, 1L * 1024 * 1024)) {
TheDrive = (CHAR)('A' + CheckingDrive);
break;
}
}
if( TheDrive == 0 ) {
//
// If there is no valid drive for the swap file, put an error message
//
DnFatalError (&DnsNoSwapDrive);
} else {
DngSwapDriveLetter = TheDrive;
}
}
BOOLEAN
DnpIsValidSwapDrive(
IN CHAR Drive,
IN ULONG SpaceRequired
)
/*++
Routine Description:
Determine if a drive is valid as a swap drive.
To be valid a drive must be extant, non-removable, local, and have
enough free space on it (as much as SpaceNeeded specifies).
Arguments:
Drive - drive letter of drive to check.
Return Value:
TRUE if Drive is valid as a swap drive. FALSE otherwise.
--*/
{
unsigned d = (unsigned)toupper(Drive) - (unsigned)'A' + 1;
struct diskfree_t DiskSpace;
ULONG SpaceAvailable;
if( DnIsDriveValid(d)
&& !DnIsDriveRemote(d,NULL)
&& !DnIsDriveRemovable(d))
{
//
// Check free space on the drive.
//
if(!_dos_getdiskfree(d,&DiskSpace)) {
SpaceAvailable = (ULONG)DiskSpace.avail_clusters
* (ULONG)DiskSpace.sectors_per_cluster
* (ULONG)DiskSpace.bytes_per_sector;
return( (BOOLEAN)(SpaceAvailable >= SpaceRequired) );
}
}
return(FALSE);
}
VOID
DnpDetermineLocalSourceDrive(
VOID
)
/*++
Routine Description:
Determine the local source drive, ie, the drive that will contain the
local copy of the windows nt setup source tree. The local source could
have been passed on the command line, in which case we will validate it.
If there was no drive specified, examine each drive in the system looking
for a local, fixed drive with enough free space on it (as specified in
the inf file).
Arguments:
None.
Return Value:
None. Sets the global variable DngTargetDriveLetter.
--*/
{
ULONG RequiredSpace;
ULONG CheckWhichDrives = 0, CheckingDrive;
CHAR SystemPartitionDriveLetter, TheDrive, DriveLetter;
DnRemoveLocalSourceTrees();
DnRemovePagingFiles();
//
// Get the space requirements for the main retail files
//
DnDetermineSpaceRequirements( SpaceRequirements,
sizeof( SpaceRequirements ) / sizeof( SPACE_REQUIREMENT ) );
//
// Determine the space requirements for the optional directories
// Note that DnpIterateOptionalDirs() will initialize the global variables
// TotalOptionalFileCount and TotalOptionalFileCount in dncopy.c with the
// total number of files in optional directory, and the total number of
// optional directories, respectively.
//
DngTargetDriveLetter = '?';
DnpIterateOptionalDirs(CPY_VALIDATION_PASS,
0,
SpaceRequirements,
sizeof( SpaceRequirements ) / sizeof( SPACE_REQUIREMENT ));
DnAdjustSpaceRequirements( SpaceRequirements,
sizeof( SpaceRequirements ) / sizeof( SPACE_REQUIREMENT ));
//
// Which drives do we need to examine?
//
if( DngFloppyless ) {
//
// Need to determine the system partition. It is usually C:
// but if C: is compressed we need to find the host drive.
//
unsigned HostDrive;
if(!DngAllowNt && DnIsDriveCompressedVolume(3,&HostDrive)) {
CheckWhichDrives |= (0x1 << (HostDrive - 1));
SystemPartitionDriveLetter = (CHAR)('A' + (HostDrive - 1));
} else {
CheckWhichDrives |= (0x1 << 2);
#if NEC_98
SystemPartitionDriveLetter = 'A';
#else
SystemPartitionDriveLetter = 'C';
#endif
}
}
if( TargetGiven ) {
if( DngAllowNt ) {
DngTargetDriveLetter = (UCHAR) toupper(*CmdLineTarget);
return;
}
CheckWhichDrives |= (0x1 << ((unsigned)toupper(*CmdLineTarget) - 'A'));
} else {
CheckWhichDrives = 0xFFFFFFFF;
}
TheDrive = 0;
for( CheckingDrive = 0; CheckingDrive < ('Z' - 'A'); CheckingDrive++ ) {
//
// Do we even need to look at this drive?
//
if( !(CheckWhichDrives & (0x1 << CheckingDrive))) {
continue;
}
DriveLetter = (CHAR)('A' + CheckingDrive);
if( DnpIsValidLocalSource( DriveLetter,
TRUE, // Check for LocalSource
(BOOLEAN)(DriveLetter == SystemPartitionDriveLetter) ) ) {
if( TargetGiven ) {
if( DriveLetter == (CHAR)toupper(*CmdLineTarget) ) {
TheDrive = DriveLetter;
}
} else {
if( !TheDrive ) {
//
// Take the first catch.
//
TheDrive = DriveLetter;
}
}
if( TheDrive ) {
//
// We found a suitable drive. But are we really done?
//
if( (DngFloppyless) &&
(DriveLetter < SystemPartitionDriveLetter) ) {
//
// We will be writing some boot files and we haven't checked
// the system partition yet. Cut to the chase.
//
CheckWhichDrives = (0x1 << (SystemPartitionDriveLetter - 'A'));
} else {
break;
}
}
} else {
//
// We need to special-handle failures on the system partition.
// See if he's capable of at least taking the system boot
// files.
//
if( (DriveLetter == SystemPartitionDriveLetter) &&
(DngFloppyless) ) {
if( !DnpIsValidLocalSource( DriveLetter,
FALSE,
TRUE )) {
//
// Consider ourselves slumped over.
//
TheDrive = 0;
break;
}
}
}
}
if( TheDrive == 0 ) {
//
// If there is no valid drive for the local source, put an error
// message with the minimum space required for C:
//
if( TargetGiven ) {
RequiredSpace = DnGetMinimumRequiredSpace(*CmdLineTarget);
} else {
#if NEC_98
RequiredSpace = DnGetMinimumRequiredSpace('A');
#else
RequiredSpace = DnGetMinimumRequiredSpace('C');
#endif
}
DnFatalError(
&DnsNoLocalSrcDrives,
(unsigned)(RequiredSpace/(1024L*1024L)),
RequiredSpace
);
} else {
//
// Use the first drive on the list.
//
DngTargetDriveLetter = TheDrive;
return;
}
}
BOOLEAN
DnpIsValidLocalSource(
IN CHAR Drive,
IN BOOLEAN CheckLocalSource,
IN BOOLEAN CheckBootFiles
)
/*++
Routine Description:
Determine if a drive is valid as a local source.
To be valid a drive must be extant, non-removable, local, and have
enough free space on it.
Arguments:
Drive - drive letter of drive to check.
Return Value:
TRUE if Drive is valid as a local source. FALSE otherwise.
--*/
{
unsigned d = (unsigned)toupper(Drive) - (unsigned)'A' + 1;
struct diskfree_t DiskSpace;
ULONG SpaceAvailable, SpaceRequired, ClusterSize;
unsigned DontCare, i;
if( DnIsDriveValid(d)
&& !DnIsDriveRemote(d,NULL)
&& !DnIsDriveRemovable(d)
&& !DnIsDriveCompressedVolume(d,&DontCare))
{
//
// Check free space on the drive.
//
if(!_dos_getdiskfree(d,&DiskSpace)) {
SpaceAvailable = (ULONG)DiskSpace.avail_clusters
* (ULONG)DiskSpace.sectors_per_cluster
* (ULONG)DiskSpace.bytes_per_sector;
ClusterSize = (ULONG)DiskSpace.sectors_per_cluster *
(ULONG)DiskSpace.bytes_per_sector;
SpaceRequired = 0;
if( CheckLocalSource ) {
for( i = 0;
i < sizeof( SpaceRequirements ) / sizeof( SPACE_REQUIREMENT );
i++ ) {
if( SpaceRequirements[i].ClusterSize == (unsigned)ClusterSize ) {
#if NEC_98
SpaceRequired += (SpaceRequirements[i].Clusters * ClusterSize + 3L * FLOPPY_SIZE);
#else
SpaceRequired += (SpaceRequirements[i].Clusters * ClusterSize);
#endif
break;
}
}
}
if( CheckBootFiles ) {
CHAR TmpBuffer[32];
PCHAR p;
sprintf( TmpBuffer, "TempDirSpace%uK", ClusterSize );
if( p = DnGetSectionKeyIndex( DngInfHandle,
DnfSpaceRequirements,
TmpBuffer,
1 ) ) {
SpaceRequired += (ULONG)atol(p);
FREE (p);
} else {
// We missed. Fudge...
ULONG FudgeSpace = 7;
FudgeSpace *= 1024;
FudgeSpace *= 1024;
SpaceRequired += FudgeSpace;
}
}
return( (BOOLEAN)(SpaceAvailable >= SpaceRequired) );
}
}
return(FALSE);
}
#if 0
BOOLEAN
DnpConstructLocalSourceList(
OUT PCHAR DriveList
)
/*++
Routine Description:
Construct a list of drives that are valid for use as a local source.
To be valid a drive must be extant, non-removable, local, and have
enough free space on it.
The 'list' is a string with a character for each valid drive, terminated
by a nul character, ie,
CDE0
Arguments:
DriveList - receives the string in the above format.
Return Value:
FALSE if no valid drives were found. TRUE if at least one was.
--*/
{
PCHAR p = DriveList;
BOOLEAN b = FALSE;
CHAR Drive;
#if NEC_98
for(Drive='A'; Drive<='Z'; Drive++) {
#else // NEC_98
for(Drive='C'; Drive<='Z'; Drive++) {
#endif // NEC_98
if(DnpIsValidLocalSource(Drive)) {
*p++ = Drive;
b = TRUE;
}
}
*p = 0;
return(b);
}
#endif
#ifdef LOGGING
// FILE *_LogFile;
BOOLEAN LogEnabled = FALSE;
VOID
StartLog(
VOID
)
{
LogEnabled = TRUE;
}
#if 0
VOID
EndLog(
VOID
)
{
if(_LogFile) {
fclose(_LogFile);
_LogFile = NULL;
}
}
#endif
VOID
__LOG(
IN PCHAR FormatString,
...
)
{
FILE *LogFile;
va_list arglist;
if(LogEnabled) {
LogFile = fopen("c:\\$winnt.log","at");
va_start(arglist,FormatString);
vfprintf(LogFile,FormatString,arglist);
va_end(arglist);
fclose(LogFile);
}
}
#endif // def LOGGING
ULONG
DnGetMinimumRequiredSpace(
IN CHAR DriveLetter
)
/*++
Routine Description:
Determine the minimum required free space for the local source, on a
particular drive.
Arguments:
DriveLetter - Indicates the letter of a particular drive.
Return Value:
Returns the minimum required space on the specified drive.
--*/
{
struct diskfree_t DiskFree;
unsigned ClusterSize;
unsigned i;
_dos_getdiskfree(toupper(DriveLetter)-'A'+1,&DiskFree);
ClusterSize = DiskFree.sectors_per_cluster * DiskFree.bytes_per_sector;
for( i = 0;
i < sizeof( SpaceRequirements ) / sizeof( SPACE_REQUIREMENT );
i++ ) {
if( ClusterSize == SpaceRequirements[i].ClusterSize ) {
return( ClusterSize * SpaceRequirements[i].Clusters );
}
}
//
// Return the size assuming 16k cluster
//
return ( SpaceRequirements[5].ClusterSize * SpaceRequirements[5].Clusters );
}
#if NEC_98
VOID
DummyRoutine(
VOID
)
/*++
This Founction is Dummy Routine.(CTRL + C Signal Hook Routine)
--*/
{
//
// It's Dummy Statement
//
while(TRUE){
break;
}
}
VOID
SearchFirstFDD(VOID)
{
UCHAR index;
UCHAR ReadPoint = 0;
UCHAR ReadCount = 1;
//
// Setting Read Data position.
//
if(SupportDos) {
ReadPoint = 27;
ReadCount = 2;
}
//
// Search First FDD.
//
FirstFD = 0;
for(index=0; index < 26; index++) {
if(LPTable[ReadPoint+index*ReadCount] == 0x90){
FirstFD = index + 1;
break;
}
}
if(FirstFD == 0) { DnFatalError(&DnsRequiresFloppy); }
return;
}
VOID
CheckTargetDrive(VOID)
{
UCHAR Pattern[127];
UCHAR TempBuf[1000];
UCHAR Current_Drv[3];
UCHAR chDeviceName[127];
UCHAR TargetPass[127];
CHAR Target_Drv[] = "?:\0";
unsigned line;
ULONG ValidKey[2];
ULONG c;
PCHAR FileName;
FILE *fileHandle;
BOOLEAN ExistNt = TRUE; // For Back up Directry Flag
ValidKey[0] = DN_KEY_F3;
ValidKey[1] = 0;
//
// C Drive(Current drive number)
//
sprintf(Current_Drv,"%c\0",DngTargetDriveLetter);
sprintf(TempBuf,DnsNtBootSect.Strings[2] ,Current_Drv);
strcpy(DnsNtBootSect.Strings[2] ,TempBuf);
Target_Drv[0] = DngTargetDriveLetter;
if(BootDiskInfo[0].DiskSector == (USHORT)256) {
DnClearClientArea();
DnDisplayScreen(&FormatError);
DnWriteStatusText("%s",DntF3EqualsExit);
while(1) {
c = DnGetValidKey(ValidKey);
if(c == DN_KEY_F3) {
FREE(BootDiskInfo);
DnExitDialog();
}
}
}
if(DngFloppyless) {
//
// Clear $WIN_NT$.~BT
//
chDeviceName[0] = (UCHAR)DngTargetDriveLetter;
chDeviceName[1] = (UCHAR)(':');
strcpy(chDeviceName+2,FLOPPYLESS_BOOT_ROOT);
if(access(chDeviceName,00) == 0) {
strcpy(Pattern,chDeviceName);
DnDelnode(Pattern);
remove(Pattern);
}
//
// Clear $WIN_NT$.~BU
//
memset(chDeviceName,0,sizeof(chDeviceName));
chDeviceName[0] = (UCHAR)DngTargetDriveLetter;
chDeviceName[1] = (UCHAR)(':');
strcpy(chDeviceName+2,"\\$WIN_NT$.~BU");
if(access(chDeviceName,00) == 0) {
//
// copy : \$WIN_NT$.~BU -> root directry
//
DnCopyFilesInSectionForFDless(DnfBackupFiles_PC98,chDeviceName,Target_Drv);
strcpy(Pattern,chDeviceName);
DnDelnode(Pattern);
remove(Pattern);
}
//
// Check Root Directry Files.
//
line = 0;
while(FileName = DnGetSectionLineIndex(DngInfHandle,DnfBackupFiles_PC98,line++,0)) {
memset(chDeviceName,0,sizeof(chDeviceName));
chDeviceName[0] = (UCHAR)DngTargetDriveLetter;
chDeviceName[1] = (UCHAR)(':');
chDeviceName[2] = (UCHAR)('\\');
strcpy(chDeviceName+3,FileName);
_dos_setfileattr(chDeviceName,_A_NORMAL);
if(fileHandle = fopen(chDeviceName,"r")) {
fclose(fileHandle);
} else {
ExistNt = FALSE;
FREE (FileName);
break;
}
FREE (FileName);
}
//
// Create $WIN_NT$.~BU
//
if(ExistNt) {
memset(chDeviceName,0,sizeof(chDeviceName));
sprintf(chDeviceName,"%c:\\$WIN_NT$.~BU",(UCHAR)DngTargetDriveLetter);
mkdir(chDeviceName);
//
// copy : root directry -> \$WIN_NT$.~BU
//
DnCopyFilesInSectionForFDless(DnfBackupFiles_PC98,Target_Drv,chDeviceName);
//
// Set files Attribute.
//
line = 0;
while(FileName = DnGetSectionLineIndex(DngInfHandle,DnfBackupFiles_PC98,line++,0)) {
memset(TargetPass,0,sizeof(TargetPass));
sprintf(TargetPass,"%c:\\$WIN_NT$.~BU\\",(UCHAR)DngTargetDriveLetter);
strcpy(TargetPass+16,FileName);
_dos_setfileattr(TargetPass,
_A_ARCH | _A_HIDDEN | _A_RDONLY | _A_SYSTEM
);
FREE (FileName);
}
}
}
}
VOID
GetLPTable(
IN PCHAR pLPTable
)
/*
Get LPTable in the Dos system.
*/
{
_asm{
push ax
push bx
push cx
push dx
push ds
mov cx,13h
push si
lds si,pLPTable
mov dx,si
pop si
int 0dch
pop ds
pop dx
pop cx
pop bx
pop ax
}
}
VOID
ClearBootFlag(
VOID
)
{
USHORT SectorSize;
PSHORT pReadBuffer;
UCHAR CNT;
(PUCHAR)DiskDAUA = MALLOC(sizeof(CONNECTDAUA)*12,TRUE);
for(CNT = 0; CNT < 12; CNT++) {
DiskDAUA[CNT].DA_UA = (UCHAR)0x00;
}
//
// Get boot device number.
//
GetDaUa();
for(CNT=0;DiskDAUA[CNT].DA_UA != 0;CNT++) {
//
// Get Device sector size.
//
SectorSize = GetSectorValue(DiskDAUA[CNT].DA_UA);
if(SectorSize == 0) {
continue;
}
pReadBuffer = (PSHORT)MALLOC(SectorSize*2,TRUE);
DiskSectorReadWrite(SectorSize,
DiskDAUA[CNT].DA_UA,
TRUE,
pReadBuffer
);
pReadBuffer[(SectorSize-6)/2] = 0x0000;
DiskSectorReadWrite(SectorSize,
DiskDAUA[CNT].DA_UA,
FALSE,
pReadBuffer
);
FREE(pReadBuffer);
}
FREE(DiskDAUA);
}
VOID
BootPartitionData(
VOID
)
/*
Setting Boot Drive Infomation for BootDiskInfo.
*/
{
UCHAR ActivePartition;
PSHORT ReadBuffers;
UCHAR SystemID;
UCHAR BootPartitionNo,CheckDosNo;
UCHAR CNT;
UCHAR ReadPoint = 0;
UCHAR ReadCount = 1;
UCHAR EndRoop = 16;
//
// Setting Read Data position.
//
if(SupportDos) {
ReadPoint = 27;
ReadCount = 2;
EndRoop = 52;
}
//
// Set Boot Device DA_UA Data value.
//
BootDiskInfo[0].DA_UA = LPTable[ReadPoint+(toupper(DngTargetDriveLetter) - 0x41)*ReadCount];
//
// Set Boot Device Sector Size.
//
BootDiskInfo[0].DiskSector = GetSectorValue(BootDiskInfo[0].DA_UA);
//
// Set Boot Drive Disk Partition Position.
//
for(CNT=ActivePartition=0;(LPTable[ReadPoint+CNT] != 0) && (CNT < EndRoop); CNT+=ReadCount) {
if(CNT > (UCHAR)(toupper(DngTargetDriveLetter)-0x41)*ReadCount)
{ break; }
if((UCHAR)LPTable[ReadPoint+CNT] == BootDiskInfo[0].DA_UA) {
ActivePartition++;
}
}
ReadBuffers = (PSHORT)MALLOC(BootDiskInfo[0].DiskSector*2,TRUE);
DiskSectorReadWrite(BootDiskInfo[0].DiskSector,
BootDiskInfo[0].DA_UA,
TRUE,
ReadBuffers
);
BootPartitionNo = CheckDosNo =0;
for(CNT=0; (CNT < 16) && (ActivePartition > CheckDosNo); CNT++) {
SystemID = *((PCHAR)ReadBuffers+(BootDiskInfo[0].DiskSector+1+32*CNT));
if( (SystemID == 0x81) || // FAT12
(SystemID == 0x91) || // FAT16
(SystemID == 0xe1) || // FAT32
((SystemID == 0xa1) && // Large partition
SupportDos))
{
CheckDosNo++;
}
BootPartitionNo++;
}
TargetDA_UA = BootDiskInfo[0].DA_UA;
Cylinders =(USHORT)*(ReadBuffers+((BootDiskInfo[0].DiskSector+10+32*(CNT-1))/2));
FREE(ReadBuffers);
BootDiskInfo[0].PartitionPosition = (UCHAR)(BootPartitionNo - 1);
}
VOID
SetAutoReboot(
VOID
)
/*++
Set Auto Reboot Flag.
--*/
{
PSHORT pReadBuffer;
pReadBuffer = (PSHORT)MALLOC(BootDiskInfo[0].DiskSector*2,TRUE);
DiskSectorReadWrite(BootDiskInfo[0].DiskSector,
BootDiskInfo[0].DA_UA,
TRUE,
pReadBuffer
);
(UCHAR)*((PCHAR)pReadBuffer+BootDiskInfo[0].DiskSector-6) = 0x80;
*((PCHAR)pReadBuffer+BootDiskInfo[0].DiskSector-5) = BootDiskInfo[0].PartitionPosition;
*((PCHAR)pReadBuffer+BootDiskInfo[0].DiskSector+32 *
BootDiskInfo[0].PartitionPosition) |= 0x80;
DiskSectorReadWrite(BootDiskInfo[0].DiskSector,
BootDiskInfo[0].DA_UA,
FALSE,
pReadBuffer
);
FREE(pReadBuffer);
}
BOOLEAN
CheckBootDosVersion(
IN UCHAR SupportDosVersion
)
/*
Get Dos Version.
*/
{
union REGS inregs,outregs;
int AXValue;
inregs.x.ax = (unsigned int)0;
inregs.x.bx = (unsigned int)0;
inregs.x.cx = (unsigned int)0;
inregs.x.dx = (unsigned int)0;
outregs.x.ax = (unsigned int)0;
outregs.x.bx = (unsigned int)0;
outregs.x.cx = (unsigned int)0;
outregs.x.dx = (unsigned int)0;
inregs.h.ah = (UCHAR)0x30;
AXValue = 0;
AXValue = intdos(&inregs,&outregs);
AXValue &= 0x00ff;
if(SupportDosVersion > (UCHAR)AXValue) {
return(FALSE);
} else {
return(TRUE);
}
}
USHORT
GetSectorValue(
IN UCHAR CheckDA_UA
)
/*++
Get Sector Value.
--*/
{
USHORT PhysicalSectorSize;
UCHAR ErrFlg;
_asm{
push ax
push bx
push cx
push dx
mov ah,84h
mov al,CheckDA_UA
int 1bh
mov PhysicalSectorSize,bx
cmp ah,00h
je break0
and ax,0f000h
cmp ax,0000h
je break0
mov ErrFlg,01h
jmp break1
break0:
mov ErrFlg,00h
break1:
pop dx
pop cx
pop bx
pop ax
}
if(ErrFlg == 0) {
return(PhysicalSectorSize);
} else {
return((USHORT)0);
}
}
BOOLEAN
DiskSectorReadWrite(
IN USHORT HDSector,
IN UCHAR ReadWriteDA_UA,
IN BOOLEAN ReadFlag,
IN PSHORT OrigReadBuffer
)
{
UCHAR ahreg = 0x06;
UCHAR ErrorFlag;
USHORT ReadSectorSize;
BOOLEAN HDStatus = TRUE;
UCHAR far *pTmp;
ULONG pAddr;
PSHORT ReadBuffer, p;
ReadSectorSize = HDSector * 2;
//
// INT 1BH does not allow the buffer that beyond 64KB boundary.
// So we must prepare particular buffer for INT 1BH. Once allocate
// double size buffer and use half of them that does not on
// boundary.
//
p = MALLOC(ReadSectorSize * 2, TRUE);
pTmp = (UCHAR far *)p;
pAddr = (FP_SEG(pTmp)<<4 + FP_OFF(pTmp) & 0xffff);
//
// Check half part of buffer is on 64KB boundary.
//
if (pAddr > ((pAddr + ReadSectorSize) & 0xffff)){
ReadBuffer = p + ReadSectorSize; // Use last half part.
} else {
ReadBuffer = p; // Use first half part.
}
if(!ReadFlag) {
ahreg = 0x05;
memcpy(ReadBuffer, OrigReadBuffer, ReadSectorSize);
}
_asm{
push ax
push bx
push cx
push dx
push es
push di
;
; If we're running under Chicago, and we're going to be
; writing, then we have to lock the volume before attempting
; absolute disk I/O
;
cmp ReadFlag,1 ; are we reading?
jae locked ; if so, skip locking step
;
; Make sure were running under Chicago.
;
mov ah,30h
int 21h
cmp al,7h
jb locked ; not Chicago
;
; We're sure we're under Chicago, so issue new
; Lock Logical Volume IOCTL
;
mov ax,440dh
mov bh,1 ; level 1 lock
mov bl,ReadWriteDA_UA ; fetch drive to lock
mov cx,084bh ; Lock Logical Volume for disk category
mov dx,1 ; set permission to allow reads and writes
int 21h
;jc locked ; ignore failure - any errors are caught below
;mov word ptr [bp-12],1 ; we successfully locked, so we must unlock
locked:
mov bx,ReadSectorSize
mov cx,0000h
mov dx,0000h
mov ax,0000h
mov ah,ahreg
mov al,ReadWriteDA_UA
push bp
push es
push ds
pop es
les di,ReadBuffer
mov bp,di
int 1bh
pop es
pop bp
jnc warp0 ;No error
cmp ah,00h
je warp0
add ax,0f000h
cmp ax,0000h
je warp0
mov ErrorFlag,01h
jmp warp1
warp0:
mov ErrorFlag,00h
warp1:
;unlock?
cmp ReadFlag,1 ; do we need to unlock?
jae done ; if not, then done.
mov ax,440dh
mov bl,ReadWriteDA_UA ; fetch drive to lock
;mov bh,0
;inc bl ; (this IOCTL uses 1-based drive numbers)
mov cx,086bh ; Unlock Logical Volume for disk category
mov dx,0
int 21h ; ignore error (hope it never happens)
done:
pop di
pop es
pop dx
pop cx
pop bx
pop ax
}
if(ReadFlag) {
memcpy(OrigReadBuffer, ReadBuffer, ReadSectorSize);
}
FREE(p);
if(ErrorFlag != 0) {
HDStatus = FALSE;
}
return(HDStatus);
}
VOID
GetDaUa(VOID)
{
UCHAR count, i = 0;
UCHAR far *ConnectEquip;
UCHAR ConnectDevice;
//
// IDE/SASI Disk Check Routine
//
MAKE_FP(ConnectEquip,(USHORT)0x55d);
ConnectDevice = *ConnectEquip;
for(count=0;count < 4;count++) {
if(ConnectDevice & (1 << count)) {
DiskDAUA[i].DA_UA = (UCHAR)(0x80 + count);
i++;
}
}
//
// SCSI Disk Check Routine
//
MAKE_FP(ConnectEquip,(USHORT)0x482);
ConnectDevice = *ConnectEquip;
for(count=0;count < 7;count++) {
if(ConnectDevice & (1 << count)) {
DiskDAUA[i].DA_UA = (UCHAR)(0xa0 + count);
i++;
}
}
}
#endif // NEC_98
Reference in a new issue Copy permalink