You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2423 lines
63 KiB
2423 lines
63 KiB
/*++
|
|
|
|
Copyright (c) 1992 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
dncopy.c
|
|
|
|
Abstract:
|
|
|
|
File copy routines for DOS-hosted NT Setup program.
|
|
|
|
Author:
|
|
|
|
Ted Miller (tedm) 1-April-1992
|
|
|
|
Revision History:
|
|
|
|
4.0 Stephane Plante (t-stepl) 11-Dec-95
|
|
Upgraded for SUR Release
|
|
|
|
--*/
|
|
|
|
|
|
#include "winnt.h"
|
|
#include <dos.h>
|
|
#include <fcntl.h>
|
|
#include <share.h>
|
|
#include <string.h>
|
|
#include <direct.h>
|
|
#include <ctype.h>
|
|
|
|
//
|
|
// Define size of buffer we initially try to allocate for file copies
|
|
// and the size we use if the initial allocation attempt fails.
|
|
//
|
|
#define COPY_BUFFER_SIZE1 (24*1024) // 64K - 512
|
|
#define COPY_BUFFER_SIZE2 (24*1024) // 24K
|
|
#define COPY_BUFFER_SIZE3 (8*1024) // 8K
|
|
|
|
|
|
|
|
typedef struct _DIRECTORY_NODE {
|
|
struct _DIRECTORY_NODE *Next;
|
|
PCHAR Directory; // never starts or ends with \.
|
|
PCHAR Symbol;
|
|
} DIRECTORY_NODE, *PDIRECTORY_NODE;
|
|
|
|
PDIRECTORY_NODE DirectoryList;
|
|
|
|
PSCREEN CopyingScreen;
|
|
|
|
BOOLEAN UsingGauge = FALSE;
|
|
|
|
//
|
|
// Total number of files to be copied
|
|
//
|
|
unsigned TotalFileCount;
|
|
|
|
//
|
|
// Total number of files in the optional directories
|
|
//
|
|
unsigned TotalOptionalFileCount = 0;
|
|
|
|
//
|
|
// Total number of optional directories
|
|
//
|
|
unsigned TotalOptionalDirCount = 0;
|
|
#if 0
|
|
// Debugging purposes
|
|
unsigned SaveTotalOptionalDirCount = 0;
|
|
#endif
|
|
|
|
//
|
|
// Buffer used for file copying and verifying,
|
|
// and the size of the buffer.
|
|
//
|
|
PVOID CopyBuffer;
|
|
unsigned CopyBufferSize;
|
|
|
|
|
|
VOID
|
|
DnpCreateDirectoryList(
|
|
IN PCHAR SectionName,
|
|
OUT PDIRECTORY_NODE *ListHead
|
|
);
|
|
|
|
VOID
|
|
DnpCreateDirectories(
|
|
IN PCHAR TargetRootDir
|
|
);
|
|
|
|
VOID
|
|
DnpCreateOneDirectory(
|
|
IN PCHAR Directory
|
|
);
|
|
|
|
BOOLEAN
|
|
DnpOpenSourceFile(
|
|
IN PCHAR Filename,
|
|
OUT int *Handle,
|
|
OUT unsigned *Attribs,
|
|
OUT BOOLEAN *UsedCompressedName
|
|
);
|
|
|
|
ULONG
|
|
DnpIterateCopyList(
|
|
IN unsigned Flags,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR DestinationRoot,
|
|
IN unsigned ClusterSize OPTIONAL
|
|
);
|
|
|
|
ULONG
|
|
DnpIterateCopyListSection(
|
|
IN unsigned Flags,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR DestinationRoot,
|
|
IN unsigned ClusterSize OPTIONAL
|
|
);
|
|
|
|
ULONG
|
|
DnpCopyOneFile(
|
|
IN unsigned Flags,
|
|
IN PCHAR SourceName,
|
|
IN PCHAR DestName
|
|
);
|
|
|
|
BOOLEAN
|
|
DnpDoCopyOneFile(
|
|
IN unsigned Flags,
|
|
IN int SrcHandle,
|
|
IN int DstHandle,
|
|
IN PCHAR Filename,
|
|
OUT PBOOLEAN Verified,
|
|
OUT PULONG BytesWritten
|
|
);
|
|
|
|
BOOLEAN
|
|
DnpLookUpDirectory(
|
|
IN PCHAR RootDirectory,
|
|
IN PDIRECTORY_NODE DirList,
|
|
IN PCHAR Symbol,
|
|
OUT PCHAR PathOut
|
|
);
|
|
|
|
VOID
|
|
DnpInfSyntaxError(
|
|
IN PCHAR Section
|
|
);
|
|
|
|
VOID
|
|
DnpFreeDirectoryList(
|
|
IN OUT PDIRECTORY_NODE *List
|
|
);
|
|
|
|
VOID
|
|
DnpFormatSpaceErrMsg(
|
|
IN ULONG NtSpaceReq,
|
|
IN ULONG CSpaceReq
|
|
);
|
|
|
|
ULONG
|
|
DnpDoIterateOptionalDir(
|
|
IN unsigned Flags,
|
|
IN PCHAR SourceDir,
|
|
IN PCHAR DestDir,
|
|
IN unsigned ClusterSize OPTIONAL,
|
|
IN PSPACE_REQUIREMENT SpaceReqArray OPTIONAL,
|
|
IN unsigned ArraySize OPTIONAL
|
|
);
|
|
|
|
VOID
|
|
DnpGenerateCompressedName(
|
|
IN PCHAR Filename,
|
|
OUT PCHAR CompressedName
|
|
);
|
|
|
|
BOOLEAN
|
|
InDriverCacheInf(
|
|
IN PVOID InfHandle,
|
|
IN PCHAR FileName
|
|
);
|
|
|
|
VOID
|
|
DnpConcatPaths(
|
|
IN PCHAR SourceBuffer,
|
|
IN PCHAR AppendString
|
|
)
|
|
{
|
|
if (SourceBuffer[strlen(SourceBuffer) -1] != '\\') {
|
|
strcat(SourceBuffer, "\\");
|
|
}
|
|
|
|
strcat(SourceBuffer,AppendString);
|
|
}
|
|
|
|
|
|
#if NEC_98
|
|
ULONG
|
|
DnpCopyOneFileForFDless(
|
|
IN PCHAR SourceName,
|
|
IN PCHAR DestName,
|
|
IN BOOLEAN Verify
|
|
);
|
|
#endif // NEC_98
|
|
|
|
VOID
|
|
DnCopyFiles(
|
|
VOID
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Top-level file copy entry point. Creates all directories listed in
|
|
the [Directories] section of the inf. Copies all files listed in the
|
|
[Files] section of the inf file from the source to the target (which
|
|
becomes the local source).
|
|
|
|
Arguments:
|
|
|
|
None.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR LocalSourceRoot;
|
|
struct diskfree_t DiskFree;
|
|
unsigned ClusterSize;
|
|
ULONG SizeOccupied;
|
|
PCHAR UdfFileName = WINNT_UNIQUENESS_DB;
|
|
PCHAR UdfPath;
|
|
|
|
//
|
|
// Do not change this without changing text setup as well
|
|
// (SpPtDetermineRegionSpace()).
|
|
//
|
|
PCHAR SizeFile = "\\size.sif";
|
|
PCHAR Lines[] = { "[Data]\n",
|
|
"Size = xxxxxxxxxxxxxx\n",
|
|
//
|
|
// Debugging purposes
|
|
//
|
|
"TotalFileCount = xxxxxxxxxxxxxx\n",
|
|
"TotalOptionalFileCount = xxxxxxxxxxxxxx\n",
|
|
"TotalOptionalDirCount = xxxxxxxxxxxxxx\n",
|
|
"ClusterSize = xxxxxxxxxxxxxx\n",
|
|
"Size_512 = xxxxxxxxxxxxxx\n",
|
|
"Size_1K = xxxxxxxxxxxxxx\n",
|
|
"Size_2K = xxxxxxxxxxxxxx\n",
|
|
"Size_4K = xxxxxxxxxxxxxx\n",
|
|
"Size_8K = xxxxxxxxxxxxxx\n",
|
|
"Size_16K = xxxxxxxxxxxxxx\n",
|
|
"Size_32K = xxxxxxxxxxxxxx\n",
|
|
#if 0
|
|
"SaveTotalOptionalDirCount = xxxxxxxxxxxxxx\n",
|
|
#endif
|
|
NULL };
|
|
|
|
DnClearClientArea();
|
|
DnDisplayScreen(CopyingScreen = &DnsWaitCopying);
|
|
DnWriteStatusText(NULL);
|
|
|
|
|
|
|
|
//
|
|
// Create the linked list of directories.
|
|
//
|
|
DnpCreateDirectoryList(DnfDirectories,&DirectoryList);
|
|
|
|
//
|
|
// Generate the full root path of the local source
|
|
//
|
|
LocalSourceRoot = MALLOC(sizeof(LOCAL_SOURCE_DIRECTORY) + strlen(x86DirName) + strlen(SizeFile),TRUE);
|
|
LocalSourceRoot[0] = DngTargetDriveLetter;
|
|
LocalSourceRoot[1] = ':';
|
|
strcpy(LocalSourceRoot+2,LocalSourceDirName);
|
|
DnpCreateOneDirectory(LocalSourceRoot);
|
|
|
|
//
|
|
// Yuck. Create this directory here because when
|
|
// we're running down the main copylist, we're expecting
|
|
// no non-existent directories in the destination name.
|
|
// There can be though. The right fix is to fix DnCopyOneFile
|
|
// to create directories if he finds them in the destination string
|
|
// sent in. This is a faster fix though.
|
|
//
|
|
{
|
|
char MyLocalSourceRoot[256];
|
|
strcpy( MyLocalSourceRoot, LocalSourceRoot );
|
|
strcat( MyLocalSourceRoot, x86DirName );
|
|
DnpCreateOneDirectory(MyLocalSourceRoot);
|
|
strcat( MyLocalSourceRoot, "\\System32" );
|
|
DnpCreateOneDirectory(MyLocalSourceRoot);
|
|
}
|
|
|
|
if(UniquenessDatabaseFile) {
|
|
UdfPath = MALLOC(strlen(LocalSourceRoot) + strlen(UdfFileName) + 2, TRUE);
|
|
strcpy(UdfPath,LocalSourceRoot);
|
|
DnpConcatPaths(UdfPath,UdfFileName);
|
|
DnpCopyOneFile(CPY_PRESERVE_ATTRIBS,UniquenessDatabaseFile,UdfPath);
|
|
FREE(UdfPath);
|
|
}
|
|
// don't need this appendage anymore - part of changes for 2CD setup.
|
|
#if 0
|
|
strcat(LocalSourceRoot,x86DirName);
|
|
#endif
|
|
|
|
//
|
|
// Determine the cluster size on the drive.
|
|
//
|
|
_dos_getdiskfree(toupper(DngTargetDriveLetter)-'A'+1,&DiskFree);
|
|
ClusterSize = DiskFree.sectors_per_cluster * DiskFree.bytes_per_sector;
|
|
|
|
//
|
|
// Pass over the copy list and check syntax.
|
|
// Note that the global variable TotalOptionalFileCount is already set
|
|
// (this was done when we determined the disk space requirements), and we
|
|
// no longer need to call DnpIterateOptionalDirs() in the validation mode
|
|
//
|
|
DnpIterateCopyList(CPY_VALIDATION_PASS | CPY_PRUNE_DRIVERCAB,DnfFiles,LocalSourceRoot,0);
|
|
|
|
//
|
|
// TotalFileCount must indicate the total number of files in the flat
|
|
// directory and optional directories.
|
|
//
|
|
TotalFileCount += TotalOptionalFileCount;
|
|
|
|
//
|
|
// Create the target directories
|
|
//
|
|
DnpCreateDirectories(LocalSourceRoot);
|
|
|
|
//
|
|
// Pass over the copy list again and actually perform the copy.
|
|
//
|
|
UsingGauge = TRUE;
|
|
SizeOccupied = DnpIterateCopyList(CPY_PRESERVE_NAME | CPY_PRUNE_DRIVERCAB,DnfFiles,LocalSourceRoot,ClusterSize);
|
|
SizeOccupied += DnpIterateOptionalDirs(0,ClusterSize,NULL,0);
|
|
//
|
|
// Free the copy buffer.
|
|
//
|
|
if(CopyBuffer) {
|
|
FREE(CopyBuffer);
|
|
CopyBuffer = NULL;
|
|
}
|
|
|
|
//
|
|
// Free the directory node list
|
|
//
|
|
DnpFreeDirectoryList(&DirectoryList);
|
|
|
|
//
|
|
// Make an approximate calculation of the amount of disk space taken up
|
|
// by the local source directory itself, assuming 32 bytes per dirent.
|
|
// Also account for the small ini file that we'll put in the local source
|
|
// directory, to tell text setup how much space the local source takes up.
|
|
//
|
|
// Takes into consideration the dirent for each file in the flat directory
|
|
// plust the directories . and .., plus size.sif, plus $win_nt_.~ls and
|
|
// $win_nt$.~ls\i386
|
|
//
|
|
SizeOccupied += ((((TotalFileCount - TotalOptionalFileCount) + // number of files in the $win_nt$.~ls\i386 directory
|
|
1 + // $win_nt$.~ls
|
|
2 + // . and .. on $win_nt$.~ls
|
|
1 + // size.sif on $win_nt$.~ls
|
|
1 + // $win_nt$.~ls\i386
|
|
2 // . and .. on $win_nt$.~ls\i386
|
|
)*32 + (ClusterSize-1)) / ClusterSize)*ClusterSize;
|
|
//
|
|
// Now take into consideration the optional directories.
|
|
//
|
|
if(TotalOptionalDirCount != 0) {
|
|
unsigned AvFilesPerOptionalDir= 0;
|
|
|
|
//
|
|
// We assume a uniform distribution of optional files on optional
|
|
// directories
|
|
//
|
|
AvFilesPerOptionalDir = (TotalOptionalFileCount + (TotalOptionalDirCount - 1))/TotalOptionalDirCount;
|
|
AvFilesPerOptionalDir += 2; // . and .. on each optional dir
|
|
SizeOccupied += (TotalOptionalDirCount*((AvFilesPerOptionalDir*32 + (ClusterSize-1))/ClusterSize))*ClusterSize;
|
|
//
|
|
// Finally take into account each optional directory
|
|
//
|
|
SizeOccupied += ((TotalOptionalDirCount*32 + (ClusterSize-1))/ClusterSize)*ClusterSize;
|
|
}
|
|
|
|
//
|
|
// Create a small ini file listing the size occupied by the local source.
|
|
// Account for the ini file in the size.
|
|
//
|
|
strcpy(LocalSourceRoot+2,LocalSourceDirName);
|
|
strcat(LocalSourceRoot,SizeFile);
|
|
sprintf(Lines[1],"Size = %lu\n",SizeOccupied);
|
|
//
|
|
// Debugging purposes
|
|
//
|
|
sprintf(Lines[2], "TotalFileCount = %u\n" ,TotalFileCount);
|
|
sprintf(Lines[3], "TotalOptionalFileCount = %u\n" ,TotalOptionalFileCount);
|
|
sprintf(Lines[4], "TotalOptionalDirCount = %u\n" ,TotalOptionalDirCount);
|
|
sprintf(Lines[5], "ClusterSize = %u\n" , ClusterSize);
|
|
sprintf(Lines[6], "Size_%u = %lu\n" , SpaceRequirements[0].ClusterSize, SpaceRequirements[0].Clusters * SpaceRequirements[0].ClusterSize);
|
|
sprintf(Lines[7], "Size_%u = %lu\n" , SpaceRequirements[1].ClusterSize, SpaceRequirements[1].Clusters * SpaceRequirements[1].ClusterSize);
|
|
sprintf(Lines[8], "Size_%u = %lu\n" , SpaceRequirements[2].ClusterSize, SpaceRequirements[2].Clusters * SpaceRequirements[2].ClusterSize);
|
|
sprintf(Lines[9], "Size_%u = %lu\n" , SpaceRequirements[3].ClusterSize, SpaceRequirements[3].Clusters * SpaceRequirements[3].ClusterSize);
|
|
sprintf(Lines[10],"Size_%u = %lu\n" , SpaceRequirements[4].ClusterSize, SpaceRequirements[4].Clusters * SpaceRequirements[4].ClusterSize);
|
|
sprintf(Lines[11],"Size_%u = %lu\n" , SpaceRequirements[5].ClusterSize, SpaceRequirements[5].Clusters * SpaceRequirements[5].ClusterSize);
|
|
sprintf(Lines[12],"Size_%u = %lu\n" , SpaceRequirements[6].ClusterSize, SpaceRequirements[6].Clusters * SpaceRequirements[6].ClusterSize);
|
|
#if 0
|
|
sprintf(Lines[13],"SaveTotalOptionalDirCount = %u\n" ,SaveTotalOptionalDirCount);
|
|
#endif
|
|
DnWriteSmallIniFile(LocalSourceRoot,Lines,NULL);
|
|
|
|
FREE(LocalSourceRoot);
|
|
}
|
|
|
|
|
|
VOID
|
|
DnCopyFloppyFiles(
|
|
IN PCHAR SectionName,
|
|
IN PCHAR TargetRoot
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Top-level entry point to copy files to the setup floppy or hard-disk
|
|
boot root when this routine is called. Copies all files listed in the
|
|
[FloppyFiles.x] sections of the inf file from the source to TargetRoot.
|
|
|
|
Arguments:
|
|
|
|
SectionName - supplies the name of the section in the inf file
|
|
that contains the list of files to be copied.
|
|
|
|
TargetRoot - supplies the target path without trailing \.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
DnClearClientArea();
|
|
DnDisplayScreen(CopyingScreen = (DngFloppyless ? &DnsWaitCopying : &DnsWaitCopyFlop));
|
|
DnWriteStatusText(NULL);
|
|
|
|
//
|
|
// Create the linked list of directories.
|
|
//
|
|
DnpCreateDirectoryList(DnfDirectories,&DirectoryList);
|
|
|
|
//
|
|
// Copy the files.
|
|
//
|
|
DnpIterateCopyList(
|
|
CPY_VALIDATION_PASS | CPY_USE_DEST_ROOT,
|
|
SectionName,
|
|
TargetRoot,
|
|
0
|
|
);
|
|
|
|
DnpIterateCopyList(
|
|
CPY_USE_DEST_ROOT | CPY_PRESERVE_NAME | (DngFloppyVerify ? CPY_VERIFY : 0),
|
|
SectionName,
|
|
TargetRoot,
|
|
0
|
|
);
|
|
|
|
//
|
|
// Free the copy buffer.
|
|
//
|
|
if(CopyBuffer) {
|
|
FREE(CopyBuffer);
|
|
CopyBuffer = NULL;
|
|
}
|
|
|
|
//
|
|
// Free the directory node list
|
|
//
|
|
|
|
DnpFreeDirectoryList(&DirectoryList);
|
|
}
|
|
|
|
|
|
VOID
|
|
DnpCreateDirectoryList(
|
|
IN PCHAR SectionName,
|
|
OUT PDIRECTORY_NODE *ListHead
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Examine a section in the INF file, whose lines are to be in the form
|
|
key = directory and create a linked list describing the key/directory
|
|
pairs found therein.
|
|
|
|
If the directory field is empty, it is assumed to be the root.
|
|
|
|
Arguments:
|
|
|
|
SectionName - supplies name of section
|
|
|
|
ListHead - receives pointer to head of linked list
|
|
|
|
Return Value:
|
|
|
|
None. Does not return if syntax error in the inf file section.
|
|
|
|
--*/
|
|
|
|
{
|
|
unsigned LineIndex,len;
|
|
PDIRECTORY_NODE DirNode,PreviousNode;
|
|
PCHAR Key;
|
|
PCHAR Dir;
|
|
PCHAR Dir1;
|
|
|
|
LineIndex = 0;
|
|
PreviousNode = NULL;
|
|
while(Key = DnGetKeyName(DngInfHandle,SectionName,LineIndex)) {
|
|
|
|
Dir1 = DnGetSectionKeyIndex(DngInfHandle,SectionName,Key,0);
|
|
|
|
if(Dir1 == NULL) {
|
|
Dir = ""; // use the root if not specified
|
|
}
|
|
else {
|
|
Dir = Dir1;
|
|
}
|
|
|
|
// 2CD setup changes - We can't do this relative roots anymore.
|
|
// All of the directories have to be absolute to the LocalSource root.
|
|
// We probably need to enforce that there is a '\' in the front.
|
|
#if 0
|
|
//
|
|
// Skip leading backslashes
|
|
//
|
|
|
|
while(*Dir == '\\') {
|
|
Dir++;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Clip off trailing backslashes if present
|
|
//
|
|
|
|
while((len = strlen(Dir)) && (Dir[len-1] == '\\')) {
|
|
Dir[len-1] = '\0';
|
|
}
|
|
|
|
DirNode = MALLOC(sizeof(DIRECTORY_NODE),TRUE);
|
|
|
|
DirNode->Next = NULL;
|
|
DirNode->Directory = DnDupString(Dir);
|
|
DirNode->Symbol = DnDupString(Key);
|
|
|
|
if(PreviousNode) {
|
|
PreviousNode->Next = DirNode;
|
|
} else {
|
|
*ListHead = DirNode;
|
|
}
|
|
PreviousNode = DirNode;
|
|
|
|
LineIndex++;
|
|
|
|
FREE (Dir1);
|
|
FREE (Key);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DnpCreateDirectories(
|
|
IN PCHAR TargetRootDir
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Create the local source directory, and run down the DirectoryList and
|
|
create directories listed therein relative to the given root dir.
|
|
|
|
Arguments:
|
|
|
|
TargetRootDir - supplies the name of root directory of the target
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDIRECTORY_NODE DirNode;
|
|
CHAR TargetDirTemp[128];
|
|
|
|
DnpCreateOneDirectory(TargetRootDir);
|
|
|
|
for(DirNode = DirectoryList; DirNode; DirNode = DirNode->Next) {
|
|
|
|
if ( DngCopyOnlyD1TaggedFiles )
|
|
{
|
|
// symbol will always exist, so we are safe in using it in
|
|
// the comparision below.
|
|
// We skip this file if the tag is not d1
|
|
if ( strcmpi(DirNode->Symbol, "d1") )
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// No need to create the root
|
|
//
|
|
if(*DirNode->Directory) {
|
|
|
|
// 2 CD Setup changes - if Directory is of the a\b\c\d then we better make sure
|
|
// we can create the entire directory structure
|
|
// We run into this when \cmpnents\tabletpc\i386 needs to be created.
|
|
CHAR *pCurDir = DirNode->Directory;
|
|
CHAR *pTargetDir;
|
|
|
|
strcpy(TargetDirTemp,TargetRootDir);
|
|
strcat(TargetDirTemp,"\\");
|
|
pCurDir++; // the first character is always bound to be '\'
|
|
pTargetDir = TargetDirTemp + strlen(TargetDirTemp);
|
|
#if 0
|
|
strcat(TargetDirTemp,DirNode->Directory);
|
|
#else
|
|
for ( ; *pCurDir; pTargetDir++, pCurDir++ )
|
|
{
|
|
if ( *pCurDir == '\\' )
|
|
{
|
|
*pTargetDir = 0;
|
|
DnpCreateOneDirectory(TargetDirTemp);
|
|
}
|
|
*pTargetDir = *pCurDir;
|
|
}
|
|
*pTargetDir = 0;
|
|
#endif
|
|
DnpCreateOneDirectory(TargetDirTemp);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DnpCreateOneDirectory(
|
|
IN PCHAR Directory
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Create a single directory if it does not already exist.
|
|
|
|
Arguments:
|
|
|
|
Directory - directory to create
|
|
|
|
Return Value:
|
|
|
|
None. Does not return if directory cannot be created.
|
|
|
|
--*/
|
|
|
|
{
|
|
struct find_t FindBuf;
|
|
int Status;
|
|
|
|
//
|
|
// First, see if there's a file out there that matches the name.
|
|
//
|
|
|
|
Status = _dos_findfirst( Directory,
|
|
_A_RDONLY | _A_HIDDEN | _A_SYSTEM | _A_SUBDIR,
|
|
&FindBuf
|
|
);
|
|
|
|
if(Status) {
|
|
|
|
//
|
|
// file could not be matched so we should be able to create the dir.
|
|
//
|
|
|
|
if(mkdir(Directory)) {
|
|
DnFatalError(&DnsCantCreateDir,Directory);
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// file matched. If it's a dir, we're OK. Otherwise we can't
|
|
// create the dir, a fatal error.
|
|
//
|
|
|
|
if(FindBuf.attrib & _A_SUBDIR) {
|
|
return;
|
|
} else {
|
|
DnFatalError(&DnsCantCreateDir,Directory);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
ULONG
|
|
DnpIterateCopyList(
|
|
IN unsigned Flags,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR DestinationRoot,
|
|
IN unsigned ClusterSize OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Run through the NtTreeFiles and BootFiles sections, validating their
|
|
syntactic correctness and copying files if directed to do so.
|
|
|
|
Arguments:
|
|
|
|
Flags - Supplies flags controlling various behavior:
|
|
|
|
CPY_VALIDATION_PASS: if set, do not actually copy the files.
|
|
If not set, copy the files as they are iterated.
|
|
|
|
CPY_USE_DEST_ROOT - if set, ignore the directory symbol and copy
|
|
each file to the DestinationRoot directory. If not set,
|
|
append the directory implied by the directory symbol for a file
|
|
to the DestinationRoot.
|
|
|
|
CPY_VERIFY - if set and this is not a validation pass, files will be
|
|
verified after they have been copied by rereading them from the
|
|
copy source and comparing with the local version that was just
|
|
copied.
|
|
|
|
SectionName - name of section coptaining the list of files
|
|
|
|
DestinationRoot- supplies the root of the destination, to which all
|
|
directories are relative.
|
|
|
|
ClusterSize - if specified, supplies the number of bytes in a cluster
|
|
on the destination. If ValidationPass is FALSE, files will be sized as
|
|
they are copied, and the return value of this function will be
|
|
the total size occupied on the target by the files that are copied
|
|
there.
|
|
|
|
Return Value:
|
|
|
|
If ValidationPass is TRUE, then the return value is the number of files
|
|
that will be copied.
|
|
|
|
If ClusterSize was specfied and ValidationPass is FALSE,
|
|
the return value is the total space occupied on the target drive
|
|
by the files that were copied. Otherwise the return value is undefined.
|
|
|
|
Does not return if a syntax error in encountered in the INF file.
|
|
|
|
--*/
|
|
|
|
{
|
|
if(Flags & CPY_VALIDATION_PASS) {
|
|
TotalFileCount = 0;
|
|
} else {
|
|
if(UsingGauge) {
|
|
DnInitGauge(TotalFileCount,CopyingScreen);
|
|
}
|
|
}
|
|
|
|
return(DnpIterateCopyListSection(Flags,SectionName,DestinationRoot,ClusterSize));
|
|
}
|
|
|
|
|
|
ULONG
|
|
DnpIterateOptionalDirs(
|
|
IN unsigned Flags,
|
|
IN unsigned ClusterSize OPTIONAL,
|
|
IN PSPACE_REQUIREMENT SpaceReqArray OPTIONAL,
|
|
IN unsigned ArraySize OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Runs down all optional dir components and add them to the copy
|
|
list
|
|
|
|
Arguments:
|
|
|
|
Flags - supplies flags controlling various behavior:
|
|
|
|
CPY_VALIDATION_PASS - If set, then do not actually copy the files.
|
|
If not set, copy the files as they are iterated.
|
|
|
|
CPY_VERIFY: if set and this is not a validation pass, files will be
|
|
verified after they have been copied by rereading them from the
|
|
copy source and comparing with the local version that was just
|
|
copied.
|
|
|
|
ClusterSize - if specified, supplies the number of bytes in a cluster
|
|
on the destination. If ValidationPass is FALSE, files will be sized as
|
|
they are copied, and the return value of this function will be
|
|
the total size occupied on the target by the files that are copied
|
|
there.
|
|
|
|
Return Value:
|
|
|
|
If CPY_VALIDATION_PASS is set, then the return value is the number of files
|
|
that will be copied.
|
|
|
|
If ClusterSize was specfied and CPY_VALIDATION_PASS is not set,
|
|
the return value is the total space occupied on the target drive
|
|
by the files that were copied. Otherwise the return value is undefined.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR Ptr;
|
|
PCHAR SourceDir;
|
|
PCHAR DestDir;
|
|
ULONG rc;
|
|
unsigned u;
|
|
BOOLEAN OemOptDirCreated = FALSE;
|
|
struct find_t FindData;
|
|
BOOLEAN OemSysDirExists;
|
|
|
|
#if 0
|
|
//
|
|
// Debugging purposes
|
|
//
|
|
SaveTotalOptionalDirCount = TotalOptionalDirCount;
|
|
#endif
|
|
TotalOptionalDirCount = 0;
|
|
|
|
|
|
for (rc=0,u=0; u < OptionalDirCount; u++ ) {
|
|
|
|
//
|
|
// For each directory build in the list build up the
|
|
// full path name to both the source and destination
|
|
// directory, then start our recursive copy engine
|
|
//
|
|
|
|
//
|
|
// Source Dir Allocation
|
|
// We want the base dir + '\'
|
|
// + oem optional dir root + '\'
|
|
// + optional dir name + '\'
|
|
// + 8.3 name + '\0'
|
|
//
|
|
if( (OptionalDirFlags[u] & OPTDIR_OEMSYS) &&
|
|
(UserSpecifiedOEMShare ) ) {
|
|
SourceDir = MALLOC( strlen(UserSpecifiedOEMShare) +
|
|
strlen(OptionalDirs[u]) + 16, TRUE );
|
|
strcpy(SourceDir,UserSpecifiedOEMShare);
|
|
if( SourceDir[strlen(SourceDir)-1] != '\\' ) {
|
|
strcat(SourceDir,"\\");
|
|
}
|
|
} else {
|
|
SourceDir = MALLOC( strlen(DngSourceRootPath) +
|
|
strlen(OptionalDirs[u]) + 16, TRUE );
|
|
strcpy(SourceDir,DngSourceRootPath);
|
|
if ((OptionalDirFlags[u] & OPTDIR_PLATFORM_INDEP) == 0) {
|
|
strcat(SourceDir,"\\");
|
|
} else {
|
|
PCHAR LastBackslash = strchr(SourceDir, '\\');
|
|
if (LastBackslash != NULL) {
|
|
*(LastBackslash + 1) = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#if 0
|
|
// No longer supported (matth)
|
|
if (OptionalDirFlags[u] & OPTDIR_OEMOPT) {
|
|
strcat(SourceDir,OemOptionalDirectory);
|
|
strcat(SourceDir,"\\");
|
|
}
|
|
#endif
|
|
strcat(SourceDir,OptionalDirs[u]);
|
|
|
|
if (OptionalDirFlags[u] & OPTDIR_OEMSYS) {
|
|
//
|
|
// Remember whether or not $OEM$ exists on the source
|
|
//
|
|
if (_dos_findfirst(SourceDir,_A_HIDDEN|_A_SYSTEM|_A_SUBDIR, &FindData) ) {
|
|
OemSysDirExists = FALSE;
|
|
} else {
|
|
OemSysDirExists = TRUE;
|
|
}
|
|
}
|
|
|
|
strcat(SourceDir,"\\");
|
|
//
|
|
// Dest Dir Allocation
|
|
// This depends if the 'SourceOnly' flag is set with the directory
|
|
// If it is, then we want to copy it $win_nt$.~ls\i386\<dir> otherwise
|
|
// we want to stick into $win_nt$.~ls\<dir>
|
|
//
|
|
if ((OptionalDirFlags[u] & OPTDIR_TEMPONLY) && !(OptionalDirFlags[u] & OPTDIR_PLATFORM_INDEP)) {
|
|
|
|
//
|
|
// Dest Dir is '<x>:' + LocalSourceDirName + x86dir + '\' +
|
|
// optional dir name + '\' + 8.3 name + '\0'
|
|
//
|
|
|
|
DestDir = MALLOC(strlen(LocalSourceDirName) +
|
|
strlen(x86DirName) +strlen(OptionalDirs[u]) + 17, TRUE);
|
|
DestDir[0] = DngTargetDriveLetter;
|
|
DestDir[1] = ':';
|
|
strcpy(DestDir+2,LocalSourceDirName);
|
|
strcat(DestDir,x86DirName);
|
|
|
|
} else if (OptionalDirFlags[u] & OPTDIR_OEMOPT) {
|
|
|
|
//
|
|
// Dest Dir is '<x>:' + LocalSourceDirName + '\' +
|
|
// $OEMOPT$ + '\' +
|
|
// optional dir name + '\' + 8.3 name + '\0'
|
|
//
|
|
|
|
DestDir = MALLOC(strlen(LocalSourceDirName) +
|
|
strlen(OemOptionalDirectory) +
|
|
strlen(OptionalDirs[u]) + 18, TRUE);
|
|
DestDir[0] = DngTargetDriveLetter;
|
|
DestDir[1] = ':';
|
|
strcpy(DestDir+2,LocalSourceDirName);
|
|
strcat(DestDir,"\\");
|
|
strcat(DestDir,OemOptionalDirectory);
|
|
|
|
|
|
if (!(Flags & CPY_VALIDATION_PASS) && !OemOptDirCreated) {
|
|
DnpCreateOneDirectory(DestDir);
|
|
OemOptDirCreated = TRUE;
|
|
TotalOptionalDirCount++;
|
|
|
|
}
|
|
|
|
} else if (OptionalDirFlags[u] & OPTDIR_OEMSYS) {
|
|
|
|
//
|
|
// Dest Dir is '<x>:' + '\' + '$' + '\' + 8.3 name + '\0'
|
|
//
|
|
// Note that on winnt case the directory $OEM$ goes to
|
|
// <drive letter>\$ directory. This is to avoid hitting the
|
|
// DOS limit of 64 characters on a path, that is more likely to
|
|
// happen if we put $OEM$ under \$win_nt$.~ls
|
|
//
|
|
|
|
DestDir = MALLOC(strlen( WINNT_OEM_DEST_DIR ) + 17, TRUE);
|
|
DestDir[0] = DngTargetDriveLetter;
|
|
DestDir[1] = ':';
|
|
DestDir[2] = '\0';
|
|
|
|
} else {
|
|
|
|
//
|
|
// Dest Dir is '<x>:' + LocalSourceDirName + '\' +
|
|
// optional dir name + '\' + 8.3 name + '\0'
|
|
//
|
|
|
|
DestDir = MALLOC(strlen(LocalSourceDirName) +
|
|
strlen(OptionalDirs[u]) + 17, TRUE);
|
|
DestDir[0] = DngTargetDriveLetter;
|
|
DestDir[1] = ':';
|
|
strcpy(DestDir+2,LocalSourceDirName);
|
|
}
|
|
|
|
//
|
|
// We need a trailing backslash at this point
|
|
//
|
|
strcat(DestDir,"\\");
|
|
|
|
//
|
|
// Keep a pointer to the place we the optional dir part of
|
|
// the string begins
|
|
//
|
|
Ptr = DestDir + strlen(DestDir);
|
|
|
|
//
|
|
// Add the optional dir name
|
|
//
|
|
if (OptionalDirFlags[u] & OPTDIR_OEMSYS) {
|
|
strcat(DestDir,WINNT_OEM_DEST_DIR);
|
|
} else {
|
|
strcat(DestDir,OptionalDirs[u]);
|
|
}
|
|
|
|
if (!(Flags & CPY_VALIDATION_PASS)) {
|
|
|
|
//
|
|
// Create the Directory now
|
|
//
|
|
|
|
while (*Ptr != '\0') {
|
|
|
|
//
|
|
// If the current pointer is a backslash then we need to
|
|
// create this subcomponent of the optional dir
|
|
//
|
|
if (*Ptr == '\\') {
|
|
|
|
//
|
|
// Replace the char with a terminator for now
|
|
//
|
|
*Ptr = '\0';
|
|
|
|
//
|
|
// Create the subdirectory
|
|
//
|
|
DnpCreateOneDirectory(DestDir);
|
|
TotalOptionalDirCount++;
|
|
|
|
//
|
|
// Restore the seperator
|
|
//
|
|
*Ptr = '\\';
|
|
}
|
|
|
|
Ptr++;
|
|
|
|
}
|
|
|
|
//
|
|
// Create the last component in the optional dir path
|
|
//
|
|
DnpCreateOneDirectory(DestDir);
|
|
TotalOptionalDirCount++;
|
|
|
|
} else {
|
|
TotalOptionalDirCount++;
|
|
}
|
|
|
|
//
|
|
// Concate the trailing backslash now
|
|
//
|
|
strcat(DestDir,"\\");
|
|
|
|
//
|
|
// If the the optional directory is $OEM$ and it doesn't exist on
|
|
// source, then assume that it exists, but it is empty
|
|
//
|
|
if ( !(OptionalDirFlags[u] & OPTDIR_OEMSYS) ||
|
|
OemSysDirExists ) {
|
|
//
|
|
// Call our recursive tree copy function
|
|
//
|
|
rc += DnpDoIterateOptionalDir(
|
|
Flags,
|
|
SourceDir,
|
|
DestDir,
|
|
ClusterSize,
|
|
SpaceReqArray,
|
|
ArraySize
|
|
);
|
|
}
|
|
|
|
//
|
|
// Free the allocated buffers
|
|
//
|
|
|
|
FREE(DestDir);
|
|
FREE(SourceDir);
|
|
|
|
} // for
|
|
|
|
//
|
|
// return our result code if we aren't a validation pass, otherwise
|
|
// return the total number of files to copy
|
|
//
|
|
|
|
return ((Flags & CPY_VALIDATION_PASS) ? (ULONG) TotalOptionalFileCount : rc);
|
|
}
|
|
|
|
ULONG
|
|
DnpDoIterateOptionalDir(
|
|
IN unsigned Flags,
|
|
IN PCHAR SourceDir,
|
|
IN PCHAR DestDir,
|
|
IN unsigned ClusterSize OPTIONAL,
|
|
IN PSPACE_REQUIREMENT SpaceReqArray OPTIONAL,
|
|
IN unsigned ArraySize OPTIONAL
|
|
)
|
|
|
|
{
|
|
ULONG TotalSize = 0;
|
|
ULONG BytesWritten = 0;
|
|
ULONG rc = 0;
|
|
PCHAR SourceEnd;
|
|
PCHAR DestEnd;
|
|
struct find_t FindData;
|
|
unsigned i;
|
|
|
|
//
|
|
// Remember where the last '\' in each of the two paths is.
|
|
// Note: that we assume that all of the dir paths have a
|
|
// terminating '\' when it is passed to us.
|
|
//
|
|
SourceEnd = SourceDir + strlen(SourceDir);
|
|
DestEnd = DestDir + strlen(DestDir);
|
|
|
|
|
|
//
|
|
// Set the WildCard search string
|
|
//
|
|
strcpy(SourceEnd,"*.*");
|
|
|
|
//
|
|
// Do the initial search
|
|
//
|
|
if(_dos_findfirst(SourceDir,_A_HIDDEN|_A_SYSTEM|_A_SUBDIR, &FindData) ) {
|
|
|
|
//
|
|
// We couldn't find anything -- return 0
|
|
//
|
|
return (0);
|
|
}
|
|
|
|
do {
|
|
|
|
//
|
|
// Form the source and dest dirs strings
|
|
//
|
|
strcpy(SourceEnd,FindData.name);
|
|
strcpy(DestEnd,FindData.name);
|
|
|
|
|
|
//
|
|
// Check to see if the entry is a subdir. Recurse into it
|
|
// unless it is '.' or '..'
|
|
//
|
|
if (FindData.attrib & _A_SUBDIR) {
|
|
|
|
PCHAR NewSource;
|
|
PCHAR NewDest;
|
|
|
|
//
|
|
// Check to see if the name is '.' or '..'
|
|
//
|
|
if (!strcmp(FindData.name,".") || !strcmp(FindData.name,"..")) {
|
|
|
|
//
|
|
// Ignore these two cases
|
|
//
|
|
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Create the new buffers for the source and dest dir names
|
|
//
|
|
|
|
NewSource = MALLOC( strlen(SourceDir) + 14, TRUE);
|
|
strcpy(NewSource,SourceDir);
|
|
if (NewSource[strlen(NewSource)-1] != '\\') {
|
|
strcat(NewSource,"\\");
|
|
}
|
|
|
|
NewDest = MALLOC( strlen(DestDir) + 14, TRUE);
|
|
strcpy(NewDest,DestDir);
|
|
|
|
if(!(Flags & CPY_VALIDATION_PASS)) {
|
|
//
|
|
// Create the directory
|
|
//
|
|
|
|
DnpCreateOneDirectory(NewDest);
|
|
}
|
|
TotalOptionalDirCount++;
|
|
|
|
//
|
|
// Trailing BackSlash
|
|
//
|
|
if (NewDest[strlen(NewDest)-1] != '\\') {
|
|
strcat(NewDest,"\\");
|
|
}
|
|
|
|
//
|
|
// Recursive call to ourselves
|
|
//
|
|
|
|
BytesWritten = DnpDoIterateOptionalDir(
|
|
Flags,
|
|
NewSource,
|
|
NewDest,
|
|
ClusterSize,
|
|
SpaceReqArray,
|
|
ArraySize
|
|
);
|
|
|
|
if(!(Flags & CPY_VALIDATION_PASS)) {
|
|
|
|
//
|
|
// We don't care about the other case since the
|
|
// function is recursive and modifies a global
|
|
// value
|
|
//
|
|
rc += BytesWritten;
|
|
|
|
}
|
|
|
|
//
|
|
// Free all of the allocated buffers
|
|
//
|
|
|
|
FREE(NewSource);
|
|
FREE(NewDest);
|
|
|
|
//
|
|
// Continue Processing
|
|
//
|
|
|
|
continue;
|
|
|
|
} // if ...
|
|
|
|
//
|
|
// Mainline case
|
|
//
|
|
if(Flags & CPY_VALIDATION_PASS) {
|
|
TotalOptionalFileCount++;
|
|
if( SpaceReqArray != NULL ) {
|
|
for( i = 0; i < ArraySize; i++ ) {
|
|
SpaceReqArray[i].Clusters += ( FindData.size + ( SpaceReqArray[i].ClusterSize - 1 ) ) / SpaceReqArray[i].ClusterSize;
|
|
}
|
|
}
|
|
} else {
|
|
|
|
BytesWritten = DnpCopyOneFile(
|
|
Flags | CPY_PRESERVE_ATTRIBS,
|
|
SourceDir,
|
|
DestDir
|
|
);
|
|
|
|
//
|
|
// Figure out how much space was taken up by the file on the target.
|
|
//
|
|
if(ClusterSize) {
|
|
|
|
TotalSize += BytesWritten;
|
|
|
|
if(BytesWritten % ClusterSize) {
|
|
TotalSize += (ULONG)ClusterSize - (BytesWritten % ClusterSize);
|
|
}
|
|
|
|
}
|
|
|
|
if(UsingGauge) {
|
|
DnTickGauge();
|
|
}
|
|
|
|
}
|
|
|
|
} while ( !_dos_findnext(&FindData) );
|
|
|
|
DnSetCopyStatusText(DntEmptyString,NULL);
|
|
|
|
rc = ((Flags & CPY_VALIDATION_PASS) ? (ULONG)TotalOptionalFileCount : (rc + TotalSize));
|
|
|
|
return (rc);
|
|
}
|
|
|
|
ULONG
|
|
DnpIterateCopyListSection(
|
|
IN unsigned Flags,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR DestinationRoot,
|
|
IN unsigned ClusterSize OPTIONAL
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Run down a particular section in the INF file making sure it is
|
|
syntactically correct and copying files if directed to do so.
|
|
|
|
Arguments:
|
|
|
|
Flags - Supplies flags controlling various behavior:
|
|
|
|
CPY_VALIDATION_PASS: if set, do not actually copy the files.
|
|
If not set, copy the files as they are iterated.
|
|
|
|
CPY_USE_DEST_ROOT - if set, ignore the directory symbol and copy
|
|
each file to the DestinationRoot directory. If not set,
|
|
append the directory implied by the directory symbol for a file
|
|
to the DestinationRoot.
|
|
|
|
CPY_VERIFY - if set and this is not a validation pass, files will be
|
|
verified after they have been copied by rereading them from the
|
|
copy source and comparing with the local version that was just
|
|
copied.
|
|
|
|
SectionName - supplies name of section in inf file to run down.
|
|
|
|
DestinationRoot- supplies the root of the destination, to which all
|
|
directories are relative.
|
|
|
|
ClusterSize - if specified, supplies the number of bytes in a cluster
|
|
on the destination. If ValidationPass is FALSE, files will be sized as
|
|
they are copied, and the return value of this function will be
|
|
the total size occupied on the target by the files that are copied
|
|
there.
|
|
|
|
Return Value:
|
|
|
|
If ValidationPass is TRUE, then the return value is the number of files
|
|
that will be copied.
|
|
|
|
If ClusterSize was specfied and ValidationPass is FALSE,
|
|
the return value is the total space occupied on the target drive
|
|
by the files that were copied. Otherwise the return value is undefined.
|
|
|
|
Does not return if a syntax error in encountered in the INF file.
|
|
|
|
--*/
|
|
|
|
{
|
|
unsigned LineIndex;
|
|
PCHAR DirSym,FileName,RenameName;
|
|
CHAR FullSourceName[128],FullDestName[128];
|
|
ULONG TotalSize;
|
|
ULONG BytesWritten;
|
|
char *p;
|
|
char *q;
|
|
|
|
|
|
|
|
TotalSize = 0;
|
|
LineIndex = 0;
|
|
while(DirSym = DnGetSectionLineIndex(DngInfHandle,SectionName,LineIndex,0)) {
|
|
|
|
if ( DngCopyOnlyD1TaggedFiles )
|
|
{
|
|
// We skip this line if the directory tag is not 'd1'
|
|
if ( strcmpi(DirSym, "d1") )
|
|
goto loop_continue;
|
|
}
|
|
|
|
FileName = DnGetSectionLineIndex(DngInfHandle,SectionName,LineIndex,1);
|
|
|
|
RenameName = DnGetSectionLineIndex( DngInfHandle,SectionName,LineIndex,2);
|
|
|
|
//
|
|
// Make sure the filename was specified.
|
|
//
|
|
if(!FileName) {
|
|
DnpInfSyntaxError(SectionName);
|
|
}
|
|
|
|
//_LOG(("File %s - Flags %x\n",FileName, Flags));
|
|
|
|
if( Flags & CPY_PRUNE_DRIVERCAB ){
|
|
|
|
if( InDriverCacheInf( DngDrvindexInfHandle, FileName )) {
|
|
|
|
//_LOG(("%s present in driver cab\n",FileName));
|
|
|
|
if( !DnGetSectionEntryExists( DngInfHandle, WINNT_D_FORCECOPYDRIVERCABFILES, FileName)){
|
|
|
|
//_LOG(("%s present in driver cab - skipping\n",FileName));
|
|
goto next_iteration;
|
|
|
|
}
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//
|
|
// If no rename name was specified, use the file name.
|
|
//
|
|
if (!RenameName) {
|
|
RenameName = FileName;
|
|
}
|
|
if (*RenameName == 0) {
|
|
FREE (RenameName);
|
|
RenameName = FileName;
|
|
}
|
|
|
|
//
|
|
// Get destination path
|
|
//
|
|
if(Flags & CPY_USE_DEST_ROOT) {
|
|
strcpy(FullDestName,DestinationRoot);
|
|
} else {
|
|
if(!DnpLookUpDirectory(DestinationRoot,DirectoryList,DirSym,FullDestName)) {
|
|
DnpInfSyntaxError(SectionName);
|
|
}
|
|
}
|
|
|
|
p = strstr( FullDestName, x86DirName );
|
|
|
|
if (p) {
|
|
p +=1;
|
|
// 2 CD Setup changes - instead of getting rid of the second i386 we get rid of the FIRST i386
|
|
#if 0
|
|
p = strstr(p, x86DirName );
|
|
if (p) {
|
|
*p = (char)NULL;
|
|
}
|
|
#else
|
|
if ( strstr(p, x86DirName) )
|
|
{
|
|
for ( q = p + strlen(x86DirName); *q ; q++, p++ )
|
|
{
|
|
*p = *q;
|
|
}
|
|
*p = (char)NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
DnpConcatPaths(FullDestName,RenameName);
|
|
|
|
//
|
|
// Get source path
|
|
//
|
|
if(!DnpLookUpDirectory(DngSourceRootPath,DirectoryList,DirSym,FullSourceName)) {
|
|
DnpInfSyntaxError(SectionName);
|
|
}
|
|
|
|
p = strstr( FullSourceName, x86DirName );
|
|
if (p) {
|
|
p +=1;
|
|
// 2 CD Setup changes - instead of getting rid of the second i386 we get rid of the FIRST i386
|
|
#if 0
|
|
p = strstr(p, x86DirName );
|
|
if (p) {
|
|
*p = (char)NULL;
|
|
}
|
|
#else
|
|
if ( strstr(p, x86DirName) )
|
|
{
|
|
for ( q = p + strlen(x86DirName) ; *q ; q++, p++ )
|
|
{
|
|
*p = *q;
|
|
}
|
|
*p = (char)NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
DnpConcatPaths(FullSourceName,FileName);
|
|
|
|
if(Flags & CPY_VALIDATION_PASS) {
|
|
TotalFileCount++;
|
|
} else {
|
|
BytesWritten = DnpCopyOneFile(
|
|
Flags & ~CPY_PRESERVE_ATTRIBS,
|
|
FullSourceName,
|
|
FullDestName
|
|
);
|
|
|
|
//
|
|
// Figure out how much space was taken up by the file on the target.
|
|
//
|
|
if(ClusterSize) {
|
|
|
|
TotalSize += BytesWritten;
|
|
|
|
if(BytesWritten % ClusterSize) {
|
|
TotalSize += (ULONG)ClusterSize - (BytesWritten % ClusterSize);
|
|
}
|
|
}
|
|
|
|
if(UsingGauge) {
|
|
DnTickGauge();
|
|
}
|
|
}
|
|
|
|
next_iteration:
|
|
|
|
|
|
if (RenameName != FileName) {
|
|
FREE (RenameName);
|
|
}
|
|
if (FileName) {
|
|
FREE (FileName);
|
|
}
|
|
|
|
loop_continue:
|
|
LineIndex++;
|
|
FREE (DirSym);
|
|
}
|
|
DnSetCopyStatusText(DntEmptyString,NULL);
|
|
|
|
return((Flags & CPY_VALIDATION_PASS) ? (ULONG)TotalFileCount : TotalSize);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DnpLookUpDirectory(
|
|
IN PCHAR RootDirectory,
|
|
IN PDIRECTORY_NODE DirList,
|
|
IN PCHAR Symbol,
|
|
OUT PCHAR PathOut
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Match a symbol to an actual directory. Scans a give list of symbol/
|
|
directory pairs and if a match is found constructs a fully qualified
|
|
pathname that never ends in '\'.
|
|
|
|
Arguments:
|
|
|
|
RootDirectory - supplies the beginning of the path spec, to be prepended
|
|
to the directory that matches the given Symbol.
|
|
|
|
DirList - supplies pointer to head of linked list of dir/symbol pairs.
|
|
|
|
Symbol - Symbol to match.
|
|
|
|
PathOut - supplies a pointer to a buffer that receives the pathname.
|
|
|
|
Return Value:
|
|
|
|
Boolean value indicating whether a match was found.
|
|
|
|
--*/
|
|
|
|
{
|
|
while(DirList) {
|
|
|
|
if(!stricmp(DirList->Symbol,Symbol)) {
|
|
|
|
strcpy(PathOut,RootDirectory);
|
|
if(*DirList->Directory) {
|
|
// 2 CD setup changes - all directories now start with \ anyway,
|
|
// so we don't need to append this.
|
|
|
|
// make sure the current path doesn't end in a '\'
|
|
if ( PathOut[strlen(PathOut)-1] == '\\')
|
|
PathOut[strlen(PathOut)-1] = '0';
|
|
|
|
strcat(PathOut,DirList->Directory);
|
|
}
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
DirList = DirList->Next;
|
|
}
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
VOID
|
|
DnpInfSyntaxError(
|
|
IN PCHAR Section
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Print an error message about a syntax error in the given section and
|
|
terminate.
|
|
|
|
Arguments:
|
|
|
|
SectionName - supplies name of section containing bad syntax.
|
|
|
|
Return Value:
|
|
|
|
None. Does not return.
|
|
|
|
--*/
|
|
|
|
{
|
|
CHAR MsgLine1[128];
|
|
|
|
snprintf(MsgLine1,sizeof(MsgLine1),DnsBadInfSection.Strings[BAD_SECTION_LINE],Section);
|
|
|
|
DnsBadInfSection.Strings[BAD_SECTION_LINE] = MsgLine1;
|
|
|
|
DnFatalError(&DnsBadInfSection);
|
|
}
|
|
|
|
|
|
ULONG
|
|
DnpCopyOneFile(
|
|
IN unsigned Flags,
|
|
IN PCHAR SourceName,
|
|
IN PCHAR DestName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies a single file.
|
|
|
|
Arguments:
|
|
|
|
Flags - supplies flags that control various behavior:
|
|
|
|
CPY_VERIFY: verify the file will be after it has been copied.
|
|
|
|
CPY_PRESERVE_ATTRIBS: preserve the DOS file attributes of
|
|
the source file.
|
|
|
|
SourceName - supplies fully qualified name of source file
|
|
|
|
DestName - supplies fully qualified name of destination file
|
|
|
|
Return Value:
|
|
|
|
None. May not return if an error occurs during the copy.
|
|
|
|
--*/
|
|
|
|
{
|
|
int SrcHandle,DstHandle;
|
|
BOOLEAN Err,Retry;
|
|
PCHAR FilenamePart;
|
|
BOOLEAN Verified;
|
|
ULONG BytesWritten = 0;
|
|
unsigned attribs;
|
|
BOOLEAN UsedCompName;
|
|
CHAR ActualDestName[128];
|
|
|
|
FilenamePart = strrchr(SourceName,'\\') + 1;
|
|
|
|
do {
|
|
DnSetCopyStatusText(DntCopying,FilenamePart);
|
|
|
|
Err = TRUE;
|
|
|
|
//_LOG(("Copy %s --> %s: ",SourceName,DestName));
|
|
|
|
if(DnpOpenSourceFile(SourceName,&SrcHandle,&attribs,&UsedCompName)) {
|
|
|
|
if((Flags & CPY_PRESERVE_NAME) && UsedCompName) {
|
|
DnpGenerateCompressedName(DestName,ActualDestName);
|
|
} else {
|
|
strcpy(ActualDestName,DestName);
|
|
}
|
|
|
|
_dos_setfileattr(ActualDestName,_A_NORMAL);
|
|
if(!_dos_creat(ActualDestName,_A_NORMAL,&DstHandle)) {
|
|
if(DnpDoCopyOneFile(Flags,SrcHandle,DstHandle,FilenamePart,&Verified,&BytesWritten)) {
|
|
//_LOG(("success\n"));
|
|
Err = FALSE;
|
|
}
|
|
_dos_close(DstHandle);
|
|
} else {
|
|
//_LOG(("unable to create target\n"));
|
|
}
|
|
_dos_close(SrcHandle);
|
|
} else {
|
|
//_LOG(("unable to open source file\n"));
|
|
}
|
|
|
|
if((Flags & CPY_PRESERVE_ATTRIBS) && (attribs & (_A_HIDDEN | _A_RDONLY | _A_SYSTEM)) && !Err) {
|
|
_dos_setfileattr(ActualDestName,attribs);
|
|
}
|
|
|
|
if(Err) {
|
|
Retry = DnCopyError(FilenamePart,&DnsCopyError,COPYERR_LINE);
|
|
if(UsingGauge) {
|
|
DnDrawGauge(CopyingScreen);
|
|
} else {
|
|
DnClearClientArea();
|
|
DnDisplayScreen(CopyingScreen);
|
|
}
|
|
DnWriteStatusText(NULL);
|
|
} else if((Flags & CPY_VERIFY) && !Verified) {
|
|
Retry = DnCopyError(FilenamePart,&DnsVerifyError,VERIFYERR_LINE);
|
|
if(UsingGauge) {
|
|
DnDrawGauge(CopyingScreen);
|
|
} else {
|
|
DnClearClientArea();
|
|
DnDisplayScreen(CopyingScreen);
|
|
}
|
|
DnWriteStatusText(NULL);
|
|
Err = TRUE;
|
|
}
|
|
} while(Err && Retry);
|
|
|
|
return(BytesWritten);
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DnpDoCopyOneFile(
|
|
IN unsigned Flags,
|
|
IN int SrcHandle,
|
|
IN int DstHandle,
|
|
IN PCHAR Filename,
|
|
OUT PBOOLEAN Verified,
|
|
OUT PULONG BytesWritten
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Perform the actual copy of a single file.
|
|
|
|
Arguments:
|
|
|
|
Flags - supplies various flags controlling behavior of this routine:
|
|
|
|
CPY_VERIFY: if set, the copied file will be verified against the
|
|
original copy.
|
|
|
|
SrcHandle - supplies the DOS file handle for the open source file.
|
|
|
|
DstHandle - supplies the DOS file handle for the open target file.
|
|
|
|
Filename - supplies the base filename of the file being copied.
|
|
This is used in the status bar at the bottom of the screen.
|
|
|
|
Verified - if CPY_VERIFY is set and the copy succeeds, this value will
|
|
receive a flag indicating whether the file verification
|
|
determined that the file was copied correctly.
|
|
|
|
BytesWritten - Receives the number of bytes written to
|
|
the target file (ie, the file size).
|
|
|
|
Return Value:
|
|
|
|
TRUE if the copy succeeded, FALSE if it failed for any reason.
|
|
If TRUE and CPY_VERIFY is set, the caller should also check the value
|
|
returned in the Verified variable.
|
|
|
|
--*/
|
|
|
|
{
|
|
unsigned BytesRead,bytesWritten;
|
|
BOOLEAN TimestampValid;
|
|
unsigned Date,Time;
|
|
PUCHAR VerifyBuffer;
|
|
|
|
//
|
|
// Assume verification will succeed. If the file is not copied correctly,
|
|
// this value will become irrelevent.
|
|
//
|
|
if(Verified) {
|
|
*Verified = TRUE;
|
|
}
|
|
|
|
//
|
|
// If the copy buffer is not already allocated, attempt to allocate it.
|
|
// The first two attempts can fail because we have a fallback size to try.
|
|
// If the third attempt fails, bail.
|
|
//
|
|
if((CopyBuffer == NULL)
|
|
&&((CopyBuffer = MALLOC(CopyBufferSize = COPY_BUFFER_SIZE1,FALSE)) == NULL)
|
|
&&((CopyBuffer = MALLOC(CopyBufferSize = COPY_BUFFER_SIZE2,FALSE)) == NULL)) {
|
|
CopyBuffer = MALLOC(CopyBufferSize = COPY_BUFFER_SIZE3,TRUE);
|
|
}
|
|
|
|
//
|
|
// Obtain the timestamp from the source file.
|
|
//
|
|
TimestampValid = (BOOLEAN)(_dos_getftime(SrcHandle,&Date,&Time) == 0);
|
|
|
|
//
|
|
// read and write chunks of the file.
|
|
//
|
|
|
|
*BytesWritten = 0L;
|
|
do {
|
|
|
|
if(_dos_read(SrcHandle,CopyBuffer,CopyBufferSize,&BytesRead)) {
|
|
//_LOG(("read error\n"));
|
|
return(FALSE);
|
|
}
|
|
|
|
if(BytesRead) {
|
|
|
|
if(_dos_write(DstHandle,CopyBuffer,BytesRead,&bytesWritten)
|
|
|| (BytesRead != bytesWritten))
|
|
{
|
|
//_LOG(("write error\n"));
|
|
return(FALSE);
|
|
}
|
|
|
|
*BytesWritten += bytesWritten;
|
|
}
|
|
} while(BytesRead == CopyBufferSize);
|
|
|
|
//
|
|
// Perserve the original timestamp.
|
|
//
|
|
if(TimestampValid) {
|
|
_dos_setftime(DstHandle,Date,Time);
|
|
}
|
|
|
|
if(Flags & CPY_VERIFY) {
|
|
|
|
union REGS RegsIn,RegsOut;
|
|
|
|
DnSetCopyStatusText(DntVerifying,Filename);
|
|
|
|
*Verified = FALSE; // assume failure
|
|
|
|
//
|
|
// Rewind the files.
|
|
//
|
|
RegsIn.x.ax = 0x4200; // seek to offset from start of file
|
|
RegsIn.x.bx = SrcHandle;
|
|
RegsIn.x.cx = 0; // offset = 0
|
|
RegsIn.x.dx = 0;
|
|
|
|
intdos(&RegsIn,&RegsOut);
|
|
if(RegsOut.x.cflag) {
|
|
goto x1;
|
|
}
|
|
|
|
RegsIn.x.bx = DstHandle;
|
|
intdos(&RegsIn,&RegsOut);
|
|
if(RegsOut.x.cflag) {
|
|
goto x1;
|
|
}
|
|
|
|
//
|
|
// Files are rewound. Start the verification process.
|
|
// Use half the buffer for reading the copy and the other half
|
|
// to read the original.
|
|
//
|
|
VerifyBuffer = (PUCHAR)CopyBuffer + (CopyBufferSize/2);
|
|
do {
|
|
if(_dos_read(SrcHandle,CopyBuffer,CopyBufferSize/2,&BytesRead)) {
|
|
goto x1;
|
|
}
|
|
|
|
if(_dos_read(DstHandle,VerifyBuffer,CopyBufferSize/2,&bytesWritten)) {
|
|
goto x1;
|
|
}
|
|
|
|
if(BytesRead != bytesWritten) {
|
|
goto x1;
|
|
}
|
|
|
|
if(memcmp(CopyBuffer,VerifyBuffer,BytesRead)) {
|
|
goto x1;
|
|
}
|
|
|
|
} while(BytesRead == CopyBufferSize/2);
|
|
|
|
*Verified = TRUE;
|
|
}
|
|
|
|
x1:
|
|
|
|
return(TRUE);
|
|
}
|
|
|
|
|
|
VOID
|
|
DnpFreeDirectoryList(
|
|
IN OUT PDIRECTORY_NODE *List
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Free a linked list of directory nodes and place NULL in the
|
|
head pointer.
|
|
|
|
Arguments:
|
|
|
|
List - supplies pointer to list head pointer; receives NULL.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PDIRECTORY_NODE n,p = *List;
|
|
|
|
while(p) {
|
|
n = p->Next;
|
|
FREE(p->Directory);
|
|
FREE(p->Symbol);
|
|
FREE(p);
|
|
p = n;
|
|
}
|
|
*List = NULL;
|
|
}
|
|
|
|
|
|
VOID
|
|
DnDetermineSpaceRequirements(
|
|
PSPACE_REQUIREMENT SpaceReqArray,
|
|
unsigned ArraySize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Read space requirements from the inf file, and initialize SpaceReqArray.
|
|
The 'space requirement' is the amount of free disk space for all files
|
|
listed on dosnet.inf. The size of the files in the optional directories
|
|
are not included in the values specified on dosnet.inf.
|
|
|
|
|
|
Arguments:
|
|
|
|
RequiredSpace - receives the number of bytes of free space on a drive
|
|
for it to be a valid local source.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
|
|
PCHAR RequiredSpaceStr;
|
|
unsigned i;
|
|
|
|
for( i = 0; i < ArraySize; i++ ) {
|
|
RequiredSpaceStr = DnGetSectionKeyIndex( DngInfHandle,
|
|
DnfSpaceRequirements,
|
|
SpaceReqArray[i].Key,
|
|
0
|
|
);
|
|
|
|
if(!RequiredSpaceStr ||
|
|
!sscanf(RequiredSpaceStr,
|
|
"%lu",
|
|
&SpaceReqArray[i].Clusters)) {
|
|
DnpInfSyntaxError(DnfSpaceRequirements);
|
|
}
|
|
SpaceReqArray[i].Clusters /= SpaceReqArray[i].ClusterSize;
|
|
|
|
if (RequiredSpaceStr) {
|
|
FREE (RequiredSpaceStr);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID
|
|
DnAdjustSpaceRequirements(
|
|
PSPACE_REQUIREMENT SpaceReqArray,
|
|
unsigned ArraySize
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Add to the SpaceRequirements array the space occupied by the temporary
|
|
directories
|
|
|
|
Arguments:
|
|
|
|
SpaceReqArray - receives the array that contains the space requirements
|
|
information.
|
|
|
|
ArraySize - Number of elements in the SpaceRequirements Array
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
unsigned i;
|
|
unsigned ClusterSize;
|
|
unsigned AvFilesPerOptionalDir;
|
|
|
|
for( i = 0; i < ArraySize; i++ ) {
|
|
ClusterSize = SpaceReqArray[i].ClusterSize;
|
|
//
|
|
// Takes into consideration the dirent for each file in the flat directory
|
|
// plust the directories . and .., plus size.sif, plus $win_nt_.~ls and
|
|
// $win_nt$.~ls\i386
|
|
//
|
|
SpaceReqArray[i].Clusters += (((TotalFileCount - TotalOptionalFileCount) + // number of files in the $win_nt$.~ls\i386 directory
|
|
1 + // $win_nt$.~ls
|
|
2 + // . and .. on $win_nt$.~ls
|
|
1 + // size.sif on $win_nt$.~ls
|
|
1 + // $win_nt$.~ls\i386
|
|
2 // . and .. on $win_nt$.~ls\i386
|
|
)*32 + (ClusterSize-1)) / ClusterSize;
|
|
//
|
|
// Now take into consideration the optional directories.
|
|
//
|
|
if(TotalOptionalDirCount != 0) {
|
|
//
|
|
// We assume a uniform distribution of optional files on optional
|
|
// directories
|
|
//
|
|
AvFilesPerOptionalDir = (TotalOptionalFileCount + (TotalOptionalDirCount - 1))/TotalOptionalDirCount;
|
|
AvFilesPerOptionalDir += 2; // . and .. on each optional dir
|
|
SpaceReqArray[i].Clusters += TotalOptionalDirCount*((AvFilesPerOptionalDir*32 + (ClusterSize-1))/ClusterSize);
|
|
//
|
|
// Finally take into account each optional directory
|
|
//
|
|
SpaceReqArray[i].Clusters += (TotalOptionalDirCount*32 + (ClusterSize-1))/ClusterSize;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DnpGenerateCompressedName(
|
|
IN PCHAR Filename,
|
|
OUT PCHAR CompressedName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Given a filename, generate the compressed form of the name.
|
|
The compressed form is generated as follows:
|
|
|
|
Look backwards for a dot. If there is no dot, append "._" to the name.
|
|
If there is a dot followed by 0, 1, or 2 charcaters, append "_".
|
|
Otherwise assume there is a 3-character extension and replace the
|
|
third character after the dot with "_".
|
|
|
|
Arguments:
|
|
|
|
Filename - supplies filename whose compressed form is desired.
|
|
|
|
CompressedName - supplies pointer to a 128-char buffer to
|
|
contain the compressed form.
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
PCHAR p,q;
|
|
|
|
strcpy(CompressedName,Filename);
|
|
p = strrchr(CompressedName,'.');
|
|
q = strrchr(CompressedName,'\\');
|
|
if(q < p) {
|
|
|
|
//
|
|
// If there are 0, 1, or 2 characters after the dot, just append
|
|
// the underscore. p points to the dot so include that in the length.
|
|
//
|
|
if(strlen(p) < 4) {
|
|
strcat(CompressedName,"_");
|
|
} else {
|
|
|
|
//
|
|
// Assume there are 3 characters in the extension. So replace
|
|
// the final one with an underscore.
|
|
//
|
|
|
|
p[3] = '_';
|
|
}
|
|
|
|
} else {
|
|
|
|
//
|
|
// No dot, just add ._.
|
|
//
|
|
|
|
strcat(CompressedName,"._");
|
|
}
|
|
}
|
|
|
|
|
|
BOOLEAN
|
|
DnpOpenSourceFile(
|
|
IN PCHAR Filename,
|
|
OUT int *Handle,
|
|
OUT unsigned *Attribs,
|
|
OUT BOOLEAN *UsedCompressedName
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Open a file by name or by compressed name. If the previous call to
|
|
this function found the compressed name, then try to open the compressed
|
|
name first. Otherwise try to open the uncompressed name first.
|
|
|
|
Arguments:
|
|
|
|
Filename - supplies full path of file to open. This should be the
|
|
uncompressed form of the filename.
|
|
|
|
Handle - If successful, receives the id for the opened file.
|
|
|
|
Attribs - if successful receives dos file attributes.
|
|
|
|
UsedCompressedName - receives a flag indicating whether we found
|
|
the compressed form of the filename (TRUE) or not (FALSE).
|
|
|
|
Return Value:
|
|
|
|
TRUE if the file was opened successfully.
|
|
FALSE if not.
|
|
|
|
--*/
|
|
|
|
{
|
|
static BOOLEAN TryCompressedFirst = FALSE;
|
|
CHAR CompressedName[128];
|
|
PCHAR names[2];
|
|
int OrdCompressed,OrdUncompressed;
|
|
int i;
|
|
BOOLEAN rc;
|
|
|
|
//
|
|
// Generate compressed name.
|
|
//
|
|
DnpGenerateCompressedName(Filename,CompressedName);
|
|
|
|
//
|
|
// Figure out which name to try to use first. If the last successful
|
|
// call to this routine opened the file using the compressed name, then
|
|
// try to open the compressed name first. Otherwise try to open the
|
|
// uncompressed name first.
|
|
//
|
|
if(TryCompressedFirst) {
|
|
OrdCompressed = 0;
|
|
OrdUncompressed = 1;
|
|
} else {
|
|
OrdCompressed = 1;
|
|
OrdUncompressed = 0;
|
|
}
|
|
|
|
names[OrdUncompressed] = Filename;
|
|
names[OrdCompressed] = CompressedName;
|
|
|
|
for(i=0, rc=FALSE; (i<2) && !rc; i++) {
|
|
|
|
if(!_dos_open(names[i],O_RDONLY|SH_DENYWR,Handle)) {
|
|
_dos_getfileattr(names[i],Attribs);
|
|
TryCompressedFirst = (BOOLEAN)(i == OrdCompressed);
|
|
*UsedCompressedName = TryCompressedFirst;
|
|
rc = TRUE;
|
|
}
|
|
}
|
|
|
|
return(rc);
|
|
}
|
|
|
|
BOOLEAN
|
|
InDriverCacheInf(
|
|
IN PVOID InfHandle,
|
|
IN PCHAR FileName
|
|
)
|
|
{
|
|
|
|
PCHAR SectionName;
|
|
unsigned int i;
|
|
BOOLEAN ret = FALSE;
|
|
|
|
if( !InfHandle )
|
|
return FALSE;
|
|
|
|
i = 0;
|
|
|
|
|
|
do{
|
|
|
|
SectionName = DnGetSectionKeyIndex(InfHandle,"Version","CabFiles",i++);
|
|
//_LOG(("Looking in %s\n",SectionName));
|
|
|
|
if( SectionName ){
|
|
|
|
//
|
|
// Search sections for our entry
|
|
//
|
|
|
|
if( DnGetSectionEntryExists( InfHandle, SectionName, FileName)){
|
|
|
|
//_LOG(("Found %s in %s\n",FileName, SectionName));
|
|
|
|
ret = TRUE;
|
|
|
|
}
|
|
|
|
FREE( SectionName );
|
|
|
|
}
|
|
}while( !ret && SectionName );
|
|
|
|
|
|
|
|
|
|
//
|
|
// If we got here we did not find the file
|
|
//
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
VOID
|
|
DnCopyFilesInSection(
|
|
IN unsigned Flags,
|
|
IN PCHAR SectionName,
|
|
IN PCHAR SourcePath,
|
|
IN PCHAR TargetPath
|
|
)
|
|
{
|
|
unsigned line;
|
|
PCHAR FileName;
|
|
PCHAR TargName;
|
|
CHAR p[128],q[128];
|
|
|
|
DnClearClientArea();
|
|
DnWriteStatusText(NULL);
|
|
|
|
line = 0;
|
|
while(FileName = DnGetSectionLineIndex(DngInfHandle,SectionName,line++,0)) {
|
|
|
|
TargName = DnGetSectionLineIndex(DngInfHandle,SectionName,line-1,1);
|
|
if(!TargName) {
|
|
TargName = FileName;
|
|
}
|
|
|
|
strcpy(p,SourcePath);
|
|
DnpConcatPaths(p,FileName);
|
|
strcpy(q,TargetPath);
|
|
DnpConcatPaths(q,TargName);
|
|
|
|
DnpCopyOneFile(Flags,p,q);
|
|
|
|
if (TargName != FileName) {
|
|
FREE (TargName);
|
|
}
|
|
FREE (FileName);
|
|
}
|
|
}
|
|
|
|
|
|
VOID
|
|
DnCopyOemBootFiles(
|
|
PCHAR TargetPath
|
|
)
|
|
{
|
|
unsigned Count;
|
|
CHAR p[128],q[128];
|
|
|
|
DnClearClientArea();
|
|
DnWriteStatusText(NULL);
|
|
|
|
for(Count=0; Count<OemBootFilesCount; Count++) {
|
|
|
|
if( UserSpecifiedOEMShare ) {
|
|
strcpy(p, UserSpecifiedOEMShare );
|
|
DnpConcatPaths(p,WINNT_OEM_TEXTMODE_DIR);
|
|
DnpConcatPaths(p,OemBootFiles[Count]);
|
|
} else {
|
|
strcpy(p, DngSourceRootPath );
|
|
DnpConcatPaths(p,WINNT_OEM_TEXTMODE_DIR);
|
|
DnpConcatPaths(p,OemBootFiles[Count]);
|
|
|
|
}
|
|
|
|
strcpy(q, TargetPath );
|
|
DnpConcatPaths(q, OemBootFiles[Count]);
|
|
|
|
DnpCopyOneFile(0,p,q);
|
|
}
|
|
}
|
|
|
|
#if NEC_98
|
|
VOID
|
|
DnCopyFilesInSectionForFDless(
|
|
IN PCHAR SectionName,
|
|
IN PCHAR SourcePath,
|
|
IN PCHAR TargetPath
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies the file in Section. for FD less setup.
|
|
SourcePath -> TargetPath
|
|
|
|
Arguments:
|
|
|
|
SectionName - [RootBootFiles] in dosnet.inf
|
|
|
|
SourcePath - Root directory.(temporary drive)
|
|
|
|
TargetPath - \$WIN_NT$.~BU(temporary drive)
|
|
|
|
Return Value:
|
|
|
|
None.
|
|
|
|
--*/
|
|
|
|
{
|
|
unsigned line;
|
|
PCHAR FileName;
|
|
PCHAR TargName;
|
|
PCHAR p,q;
|
|
|
|
DnClearClientArea();
|
|
DnWriteStatusText(NULL);
|
|
|
|
line = 0;
|
|
while(FileName = DnGetSectionLineIndex(DngInfHandle,SectionName,line++,0)) {
|
|
|
|
TargName = DnGetSectionLineIndex(DngInfHandle,SectionName,line-1,1);
|
|
if(!TargName) {
|
|
TargName = FileName;
|
|
}
|
|
|
|
p = MALLOC(strlen(SourcePath) + strlen(FileName) + 2,TRUE);
|
|
q = MALLOC(strlen(TargetPath) + strlen(TargName) + 2,TRUE);
|
|
|
|
sprintf(p,"%s\\%s",SourcePath,FileName);
|
|
sprintf(q,"%s\\%s",TargetPath,TargName);
|
|
|
|
DnpCopyOneFileForFDless(p,q,FALSE);
|
|
|
|
FREE(p);
|
|
FREE(q);
|
|
|
|
if (TargName != FileName) {
|
|
FREE (TargName);
|
|
}
|
|
FREE (FileName);
|
|
}
|
|
}
|
|
|
|
|
|
ULONG
|
|
DnpCopyOneFileForFDless(
|
|
IN PCHAR SourceName,
|
|
IN PCHAR DestName,
|
|
IN BOOLEAN Verify
|
|
)
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copies a single file. for FD less setup.
|
|
|
|
Arguments:
|
|
|
|
SourceName - supplies fully qualified name of source file
|
|
|
|
DestName - supplies fully qualified name of destination file
|
|
|
|
Verify - if TRUE, the file will be verified after it has been copied.
|
|
|
|
Return Value:
|
|
|
|
None. May not return if an error occurs during the copy.
|
|
|
|
--*/
|
|
|
|
{
|
|
int SrcHandle,DstHandle;
|
|
PCHAR FilenamePart;
|
|
BOOLEAN Verified;
|
|
ULONG BytesWritten = 0;
|
|
unsigned attribs, verifyf = 0;
|
|
BOOLEAN UsedCompName;
|
|
|
|
FilenamePart = strrchr(SourceName,'\\') + 1;
|
|
|
|
DnSetCopyStatusText(DntCopying,FilenamePart);
|
|
|
|
if(DnpOpenSourceFile(SourceName, &SrcHandle, &attribs, &UsedCompName)) {
|
|
_dos_setfileattr(DestName,_A_NORMAL);
|
|
if (Verify)
|
|
verifyf = CPY_VERIFY;
|
|
if(!_dos_creat(DestName,_A_NORMAL,&DstHandle)) {
|
|
DnpDoCopyOneFile(verifyf, SrcHandle,DstHandle,FilenamePart,&Verified,&BytesWritten);
|
|
_dos_close(DstHandle);
|
|
}
|
|
_dos_close(SrcHandle);
|
|
}
|
|
|
|
return(BytesWritten);
|
|
}
|
|
#endif // NEC_98
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|