888 lines
23 KiB
C
888 lines
23 KiB
C
/*
|
|
* copy.c - Copy routine for WinDosSetup
|
|
* Todd Laney
|
|
*
|
|
* Modification History:
|
|
*
|
|
* 6/03/91 Vlads Change copy process to incorporate new Install API
|
|
*
|
|
* 3/24/89 Toddla Wrote it
|
|
*
|
|
*
|
|
* notes:
|
|
* we now use the LZCopy stuff for compression
|
|
* we now set the crit error handler ourselves so CHECKFLOPPY is
|
|
* NOT defined
|
|
*/
|
|
|
|
#include <windows.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <mmsystem.h>
|
|
|
|
#include "drivers.h"
|
|
#include "sulib.h"
|
|
//#include <ver.h>
|
|
|
|
|
|
#define MAX_COPY_ATTEMPTS 15
|
|
|
|
/*
|
|
* Maximum number of install disks we support
|
|
*/
|
|
|
|
#define MAX_DISKS 100
|
|
|
|
/*
|
|
* Flags for VerInstallFile
|
|
*/
|
|
|
|
#define FORCEABLE_FLAGS (VIF_MISMATCH + VIF_SRCOLD + VIF_DIFFLANG + VIF_DIFFTYPE + VIF_DIFFCODEPG )
|
|
|
|
/**********************************************************************
|
|
*
|
|
* Local function prototypes.
|
|
*
|
|
**********************************************************************/
|
|
|
|
// Retrieve disk path for logical disk
|
|
|
|
BOOL GetDiskPath(LPTSTR Disk, LPTSTR szPath);
|
|
|
|
// Convert VIF_... to ERROR... return codes
|
|
|
|
UINT ConvertFlagToValue(DWORD dwFlags);
|
|
|
|
// Do the work of trying to copy a file
|
|
|
|
LONG TryCopy(LPTSTR szSrc, // Full source file path
|
|
LPTSTR szLogSrc, // Logical source name
|
|
LPTSTR szDestPath,// Destination path
|
|
FPFNCOPY fpfnCopy); // Callback routine
|
|
|
|
#ifdef CHECK_FLOPPY
|
|
BOOL NEAR IsDiskInDrive(int iDisk);
|
|
#endif
|
|
|
|
// GLOBAL VARIABLES
|
|
|
|
// directory where windows will be setup to
|
|
|
|
TCHAR szSetupPath[MAX_PATH];
|
|
|
|
// directory where the root of the setup disks are!
|
|
|
|
TCHAR szDiskPath[MAX_PATH];
|
|
|
|
// Name of driver being copied (or oemsetup.inf)
|
|
|
|
TCHAR szDrv[120];
|
|
|
|
/*
|
|
* global vars used by DosCopy
|
|
*/
|
|
static LPTSTR lpBuf = NULL; // copy buffer
|
|
static int iBuf = 0; // usage count
|
|
static UINT nBufSize;
|
|
BOOL bRetry = FALSE;
|
|
BOOL bQueryExist;
|
|
|
|
extern BOOL bCopyEvenIfOlder; // From DRIVERS.C
|
|
|
|
|
|
BOOL DefCopyCallback(int msg, DWORD_PTR n, LPTSTR szFile)
|
|
{
|
|
return FC_IGNORE;
|
|
}
|
|
|
|
|
|
|
|
/* UINT FileCopy (szSource, szDir, fpfnCopy, UINT fCopy)
|
|
*
|
|
* This function will copy a group of files to a single destination
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* szSourc : pointer to a SETUP.INF section
|
|
* szDir : pointer to a string containing the target DIR
|
|
* fpfnCopy : callback function used to notify called of copy status
|
|
* fCopy : flags
|
|
*
|
|
* FC_SECTION - szSource is a section name
|
|
* FC_LIST - szSource is a pointer to a char **foo;
|
|
* FC_LISTTYPE - szSource is a pointer to a char *foo[];
|
|
* FC_FILE - szSource is a file name.
|
|
* FC_QUALIFIED - szSource is a fully qualified file name.
|
|
* FC_DEST_QUALIFIED - szDir is fully qualified. Don't expand this.
|
|
* FC_CALLBACK_WITH_VER - call back if file exists and report version information.
|
|
*
|
|
* NOTES:
|
|
* if szSource points to a string of the form '#name' the section
|
|
* named by 'name' will be used as the source files
|
|
*
|
|
* the first field of each line in the secion is used as the name of the
|
|
* source file. A file name has the following form:
|
|
*
|
|
* #:name
|
|
*
|
|
* # - Disk number containing file 1-9,A-Z
|
|
* name - name of the file, may be a wild card expression
|
|
*
|
|
* Format for copy status function
|
|
*
|
|
* BOOL FAR PASCAL CopyStatus(int msg, int n, LPSTR szFile)
|
|
*
|
|
* msg:
|
|
* COPY_ERROR error occured while copying file(s)
|
|
* n is the DOS error number
|
|
* szFile is the file that got the error
|
|
* return: TRUE ok, FALSE abort copy
|
|
*
|
|
* COPY_STATUS Called each time a new file is copied
|
|
* n is the percent done
|
|
* szFile is the file being copied
|
|
* return: TRUE ok, FALSE abort copy
|
|
*
|
|
* COPY_INSERTDISK Please tell the user to insert a disk
|
|
* n is the disk needed ('1' - '9')
|
|
* return: TRUE try again, FALSE abort copy
|
|
*
|
|
* COPY_QUERYCOPY Should this file be copied?
|
|
* n line index in SETUP.INF section (0 based)
|
|
* szFile is the line from section
|
|
* return: TRUE copy it, FALSE dont copy
|
|
*
|
|
* COPY_START Sent before any files are copied
|
|
*
|
|
* COPY_END Sent after all files have been copied
|
|
* n is dos error if copy failed
|
|
*
|
|
* COPY_EXISTS Sent if the FC_CALL_ON_EXIST bit was set
|
|
* and the file exists at the destination
|
|
* given for the filecopy.
|
|
*
|
|
*
|
|
* EXIT: returns TRUE if successful, FALSE if failure.
|
|
*
|
|
*/
|
|
|
|
UINT FileCopy (LPTSTR szSource, LPTSTR szDir, FPFNCOPY fpfnCopy, UINT fCopy)
|
|
{
|
|
int err = ERROR_SUCCESS; // Return code from this routine
|
|
|
|
TCHAR szPath[MAX_PATH];
|
|
TCHAR szLogSrc[MAX_PATH];
|
|
TCHAR szSrc[MAX_PATH];
|
|
|
|
LPTSTR pFileBegin; // First file
|
|
|
|
LPTSTR * List; // Handle lists of files
|
|
LPTSTR * ListHead;
|
|
|
|
int nDisk; // The disk we're on
|
|
|
|
int cntFiles = 0; // How many files we've got to do
|
|
|
|
if (fpfnCopy == NULL) {
|
|
fpfnCopy = DefCopyCallback;
|
|
}
|
|
|
|
if (!szSource || !*szSource || !szDir || !*szDir) {
|
|
return ERROR_FILE_NOT_FOUND;
|
|
}
|
|
|
|
|
|
/*
|
|
* fix up the drive in the destination
|
|
*/
|
|
|
|
if ( fCopy & FC_DEST_QUALIFIED ) {
|
|
lstrcpy(szPath, szDir);
|
|
fCopy &= ~FC_DEST_QUALIFIED;
|
|
} else {
|
|
ExpandFileName(szDir, szPath);
|
|
}
|
|
|
|
if (szSource[0] == TEXT('#') && fCopy == FC_FILE) {
|
|
fCopy = FC_SECTION;
|
|
++szSource;
|
|
}
|
|
|
|
switch (fCopy) {
|
|
case FC_SECTION:
|
|
{
|
|
szSource = infFindSection(NULL,szSource);
|
|
|
|
/*
|
|
* We are called even when the section doesn't exist
|
|
*/
|
|
|
|
if (szSource == NULL) {
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
fCopy = FC_LIST;
|
|
}
|
|
// fall through to FC_LIST
|
|
|
|
case FC_LIST:
|
|
pFileBegin = szSource;
|
|
cntFiles = infLineCount(szSource);
|
|
break;
|
|
|
|
case FC_LISTTYPE:
|
|
ListHead = List = (LPTSTR far *)szSource;
|
|
pFileBegin = *ListHead;
|
|
while ( *List++ ) // Count files to be copied.
|
|
++cntFiles;
|
|
break;
|
|
|
|
case FC_FILE:
|
|
case FC_QUALIFIED:
|
|
default:
|
|
pFileBegin = szSource;
|
|
cntFiles = 1;
|
|
}
|
|
|
|
/*
|
|
* walk all files in the list and call TryCopy ....
|
|
*
|
|
* NOTES:
|
|
* we must walk file list sorted by disk number.
|
|
* we should use the disk that is currently inserted.
|
|
* we should do a find first/find next on the files????
|
|
* we need to check for errors.
|
|
* we need to ask the user to insert disk in drive.
|
|
*
|
|
*/
|
|
|
|
(*fpfnCopy)(COPY_START,0,NULL);
|
|
|
|
/*
|
|
* Go through all possible disks: 1 to 100 and A to Z (26)
|
|
*/
|
|
|
|
for (nDisk = 1;
|
|
err == ERROR_SUCCESS && (cntFiles > 0) &&
|
|
(nDisk <= MAX_DISKS + 'Z' - 'A' + 1);
|
|
nDisk++)
|
|
{
|
|
TCHAR Disk[10]; // Maximum string is "100:"
|
|
LPTSTR pFile;
|
|
int FileNumber; // Which file in the list we're on
|
|
// (to pass to callback)
|
|
|
|
pFile = pFileBegin; // Start at first file
|
|
List = ListHead; // Handled chained lists
|
|
FileNumber = 0; // Informational for callback - gives
|
|
// which file in list we're on
|
|
/*
|
|
* Work out the string representing our disk letter
|
|
*/
|
|
|
|
if (nDisk > MAX_DISKS) {
|
|
Disk[0] = TEXT('A') + nDisk - MAX_DISKS - 1;
|
|
Disk[1] = TEXT('\0');
|
|
} else {
|
|
_itow(nDisk, Disk, 10);
|
|
}
|
|
|
|
wcscat(Disk, TEXT(":"));
|
|
|
|
for (;
|
|
err == ERROR_SUCCESS && pFile;
|
|
FileNumber++,
|
|
pFile = fCopy == FC_LISTTYPE ? *(++List) :
|
|
fCopy == FC_LIST ? infNextLine(pFile) :
|
|
NULL)
|
|
{
|
|
/*
|
|
* We have to reset high bit of first byte because it could be set
|
|
* by translating service in OEM setup to show that file name was
|
|
* mapped
|
|
*/
|
|
|
|
*pFile = toascii(*pFile);
|
|
|
|
|
|
/*
|
|
* should we copy this file?
|
|
* copy the files in disk order.
|
|
*/
|
|
|
|
if (_wcsnicmp(pFile, Disk, wcslen(Disk)) == 0 || // File has disk
|
|
// number and we're
|
|
// on that disk
|
|
RemoveDiskId(pFile) == pFile &&
|
|
nDisk == 1 && *pFile || // First disk and
|
|
// no disk number
|
|
|
|
fCopy == FC_QUALIFIED) { // Fully qualified
|
|
|
|
|
|
/*
|
|
* done with a file. decrement count.
|
|
*/
|
|
|
|
cntFiles--;
|
|
|
|
lstrcpy(szDrv, RemoveDiskId(pFile));
|
|
|
|
switch ((*fpfnCopy)(COPY_QUERYCOPY, FileNumber, pFile))
|
|
{
|
|
case CopyCurrent: // Skip
|
|
|
|
continue;
|
|
|
|
case CopyNeither:
|
|
|
|
err = ERROR_FILE_EXISTS; // File already exists
|
|
|
|
case CopyNew:
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
/*
|
|
* Pick up bad return code from switch
|
|
*/
|
|
|
|
if (err != ERROR_SUCCESS) {
|
|
break;
|
|
}
|
|
|
|
/*
|
|
* now we convert logical dest into a physical
|
|
* (unless FC_QUALIFIED)
|
|
*/
|
|
|
|
infParseField(pFile, 1, szLogSrc); // logical source
|
|
|
|
if ( fCopy != FC_QUALIFIED ) {
|
|
ExpandFileName(szLogSrc, szSrc); // full physical source
|
|
} else {
|
|
lstrcpy(szSrc,szLogSrc);
|
|
}
|
|
|
|
|
|
/*
|
|
* Attempt copy
|
|
*/
|
|
|
|
err = TryCopy(szSrc, // Qualified Source file
|
|
szLogSrc, // Logical source file name (with disk #)
|
|
szPath, // Path for directory to install in
|
|
fpfnCopy); // Copy callback function
|
|
|
|
/*
|
|
* If failed to find file try the windows directory
|
|
*/
|
|
|
|
if (err != ERROR_SUCCESS) {
|
|
break;
|
|
}
|
|
|
|
} /* End if dor if DoCopy */
|
|
}
|
|
}
|
|
|
|
(*fpfnCopy)(COPY_END,err,NULL);
|
|
|
|
return err;
|
|
}
|
|
|
|
/**********************************************************************
|
|
*
|
|
* TryCopy
|
|
*
|
|
* Copy a single file from source to destination using the VerInstallFile
|
|
* API - interpreting the return code as :
|
|
*
|
|
* ERROR_SUCCESS - OK
|
|
* Other - failure type
|
|
*
|
|
**********************************************************************/
|
|
|
|
LONG TryCopy(LPTSTR szSrc, // Full expanded source file path
|
|
LPTSTR szLogSrc, // Logical source name
|
|
LPTSTR szDestPath, // Destination path
|
|
FPFNCOPY fpfnCopy) // Callback routine
|
|
|
|
{
|
|
DWORD wTmpLen;
|
|
DWORD dwRetFlags;
|
|
TCHAR szTempFile[MAX_PATH];
|
|
TCHAR szErrFile[MAX_PATH];
|
|
TCHAR DriversPath[MAX_PATH];
|
|
BOOL bRetVal; // Return code from callback
|
|
LPTSTR szFile;
|
|
TCHAR szSrcPath[MAX_PATH];
|
|
int iAttemptCount;
|
|
WORD wVerFlags;
|
|
LONG err;
|
|
|
|
/*
|
|
* Fix up destination if file is a kernel driver
|
|
*/
|
|
|
|
if (IsFileKernelDriver(szSrc) && szDestPath)
|
|
{
|
|
wcscpy(DriversPath, szDestPath);
|
|
wcscat(DriversPath, TEXT("\\drivers"));
|
|
szDestPath = DriversPath;
|
|
}
|
|
|
|
/*
|
|
* Create file name from current string
|
|
*/
|
|
|
|
szFile = FileName(szSrc);
|
|
lstrcpy(szSrcPath, szSrc);
|
|
StripPathName(szSrcPath);
|
|
|
|
for(iAttemptCount = 0, wVerFlags = 0 ;
|
|
iAttemptCount <= MAX_COPY_ATTEMPTS;
|
|
iAttemptCount++) {
|
|
|
|
HCURSOR hcurPrev; // Saved cursor state
|
|
|
|
// Central operation - attempt to install file szFile in directory
|
|
// pointed by szPath from directory pointed by szSrc
|
|
// If operation will fail but with possibility to force install
|
|
// in last parameter buffer we will have temporary file name ==>
|
|
// therefore we can avoid excessive copying.
|
|
// NOTE: now szFile consists of only file name and other buffers
|
|
// only path names.
|
|
|
|
wTmpLen = MAX_PATH;
|
|
|
|
hcurPrev = SetCursor(LoadCursor(NULL,IDC_WAIT));
|
|
dwRetFlags = VerInstallFile(wVerFlags,
|
|
(LPTSTR) szFile,
|
|
(LPTSTR) szFile,
|
|
(LPTSTR) szSrcPath,
|
|
(LPTSTR) szDestPath,
|
|
(LPTSTR) szDestPath,
|
|
(LPTSTR) szTempFile,
|
|
(LPDWORD) &wTmpLen);
|
|
SetCursor(hcurPrev);
|
|
|
|
/*
|
|
* Operation failed if at least one bit of return flags is non-zero
|
|
* That is unusual but defined so in Version API.
|
|
*/
|
|
|
|
if ( !dwRetFlags )
|
|
return ERROR_SUCCESS; // If no errors - goto next file
|
|
|
|
|
|
/*
|
|
* If flag MISMATCH is set - install can be forced and we have
|
|
* temporary file in destination subdirectory
|
|
*/
|
|
|
|
if ( dwRetFlags & VIF_MISMATCH ) {
|
|
|
|
if ( (dwRetFlags & VIF_SRCOLD) && (!bCopyEvenIfOlder) ) {
|
|
|
|
/*
|
|
* If we need not call back with question - automatically
|
|
* force install with same parameters.
|
|
* michaele, *only* if src file is *newer* than dst file
|
|
*/
|
|
|
|
DeleteFile(szTempFile);
|
|
|
|
return ERROR_SUCCESS;
|
|
}
|
|
|
|
/*
|
|
* If we need not call back with question - automatically
|
|
* force install with same parameters.
|
|
*/
|
|
|
|
wVerFlags |= VIFF_FORCEINSTALL;
|
|
iAttemptCount--; // Make sure we get another go.
|
|
continue;
|
|
|
|
} /* End if MISMATCH */
|
|
|
|
/*
|
|
* If real error occured - call back with error file info
|
|
* In all dialogs we use our error codes - so I will convert
|
|
* flags returned from Ver API to ours.
|
|
*/
|
|
|
|
err = ConvertFlagToValue(dwRetFlags);
|
|
|
|
|
|
/*
|
|
* If source path or file is nor readable - try to change disk
|
|
*/
|
|
|
|
if ( dwRetFlags & VIF_CANNOTREADSRC )
|
|
{
|
|
/*
|
|
* Now new path in szSrc so I deleted logic for creating it
|
|
*/
|
|
|
|
if (RemoveDiskId(szLogSrc) == szLogSrc)
|
|
|
|
/*
|
|
* if disk # not provided, default to 1
|
|
*/
|
|
|
|
bRetVal = (*fpfnCopy)(COPY_INSERTDISK, (DWORD_PTR)"1", szSrcPath);
|
|
else
|
|
bRetVal = (*fpfnCopy)(COPY_INSERTDISK, (DWORD_PTR)szLogSrc, szSrcPath);
|
|
|
|
|
|
switch (bRetVal)
|
|
{
|
|
case FC_RETRY:
|
|
continue; // and try again...
|
|
|
|
case FC_ABORT:
|
|
return ERROR_FILE_NOT_FOUND;
|
|
|
|
case FC_IGNORE:
|
|
break;
|
|
}
|
|
}
|
|
|
|
ExpandFileName(szLogSrc, szErrFile);
|
|
|
|
#if WINDOWSDIR
|
|
|
|
if (!*bWindowsDir &&
|
|
err != FC_ERROR_LOADED_DRIVER &&
|
|
err != ERROR_DISK_FULL)
|
|
{
|
|
GetWindowsDirectory(szPath, MAX_PATH);
|
|
*bWindowsDir = TRUE;
|
|
continue;
|
|
}
|
|
|
|
#endif // WINDOWSDIR
|
|
|
|
switch ((*fpfnCopy)(COPY_ERROR, err, szErrFile)) {
|
|
|
|
case FC_IGNORE:
|
|
return ERROR_SUCCESS;
|
|
|
|
case FC_RETRY:
|
|
break;
|
|
|
|
case FC_ABORT:
|
|
return ERROR_FILE_NOT_FOUND;
|
|
}
|
|
} // End of attempts
|
|
|
|
return err;
|
|
}
|
|
|
|
/* BOOL GetDiskPath(Disk, szPath)
|
|
*
|
|
* This function will retrive the full path name for a logical disk
|
|
*
|
|
* The code reads the [disks] section of SETUP.INF and looks for
|
|
* n = path where n is the disk char. NOTE the disk '0' defaults to
|
|
* the root windows directory.
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* cDisk : what disk to find 0-9,A-Z
|
|
* szPath : buffer to hold disk path
|
|
*
|
|
* Returns :
|
|
* TRUE if a disk path was found
|
|
* FALSE if there was no disk specified (ie no ':'
|
|
*
|
|
*/
|
|
|
|
BOOL GetDiskPath(LPTSTR Disk, LPTSTR szPath)
|
|
{
|
|
TCHAR ach[MAX_PATH];
|
|
TCHAR szBuf[MAX_PATH];
|
|
int i;
|
|
|
|
|
|
/*
|
|
* Check to see if there is actually a disk id.
|
|
* If not return FALSE
|
|
*/
|
|
|
|
if (RemoveDiskId(Disk) == Disk) {
|
|
return FALSE;
|
|
}
|
|
|
|
/*
|
|
* Create our copy of the disk id
|
|
*/
|
|
|
|
for (i = 0; Disk[i] != TEXT(':'); i++) {
|
|
ach[i] = Disk[i];
|
|
}
|
|
ach[i] = TEXT('\0');
|
|
|
|
|
|
/*
|
|
* Zero disk letter means windows setup directory
|
|
*/
|
|
|
|
if (_wcsicmp(ach, TEXT("0")) == 0) {
|
|
|
|
/*
|
|
* return the windows setup directory
|
|
*/
|
|
|
|
lstrcpy(szPath,szSetupPath);
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
* now look in the [disks] section for a full path name
|
|
*
|
|
* This is a pretty bogus concept and is not supported
|
|
* in win 32 style disks section [Source Media Descriptions]
|
|
*/
|
|
|
|
if ( !infGetProfileString(NULL,DISK_SECT,ach,szPath) &&
|
|
!infGetProfileString(NULL,OEMDISK_SECT,ach,szPath)) {
|
|
|
|
lstrcpy(szPath, szDiskPath);
|
|
} else {
|
|
infParseField(szPath,1,szPath);
|
|
|
|
/*
|
|
* is the path relative? is so prepend the szDiskPath
|
|
*/
|
|
|
|
if (szPath[0] == TEXT('.') || szPath[0] == TEXT('\0')) {
|
|
lstrcpy(szBuf,szDiskPath);
|
|
catpath(szBuf,szPath);
|
|
lstrcpy(szPath,szBuf);
|
|
}
|
|
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* BOOL FAR PASCAL ExpandFileName(LPSTR szFile, LPTSTR szPath)
|
|
*
|
|
* This function will retrive the full path name for a file
|
|
* it will expand, logical disk letters to pyshical ones
|
|
* will use current disk and directory if non specifed.
|
|
*
|
|
* if the drive specifed is 0-9, it will expand the drive into a
|
|
* full pathname using GetDiskPath()
|
|
*
|
|
* IE 0:system ==> c:windows\system
|
|
* 1:foo.txt a:\foo.txt
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* szFile : File name to expand
|
|
* szPath : buffer to hold full file name
|
|
*
|
|
*/
|
|
BOOL ExpandFileName(LPTSTR szFile, LPTSTR szPath)
|
|
{
|
|
TCHAR szBuf[MAX_PATH*2];
|
|
|
|
if (GetDiskPath(szFile, szBuf)) {
|
|
lstrcpy(szPath,szBuf);
|
|
if (szFile[2])
|
|
catpath(szPath,szFile + 2);
|
|
} else {
|
|
lstrcpy(szPath,szFile);
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
|
|
void catpath(LPTSTR path, LPTSTR sz)
|
|
{
|
|
//
|
|
// Remove any drive letters from the directory to append
|
|
//
|
|
sz = RemoveDiskId(sz);
|
|
|
|
//
|
|
// Remove any current directories ".\" from directory to append
|
|
//
|
|
while (sz[0] == TEXT('.') && SLASH(sz[1]))
|
|
sz += 2;
|
|
|
|
//
|
|
// Dont append a NULL string or a single "."
|
|
//
|
|
if (*sz && ! (sz[0] == TEXT('.') && sz[1] == 0))
|
|
{
|
|
// Add a slash separator if necessary.
|
|
if ((! SLASH(path[lstrlen(path) - 1])) && // slash at end of path
|
|
((path[lstrlen(path) - 1]) != TEXT(':')) && // colon at end of path
|
|
(! SLASH(sz[0]))) // slash at beginning of file
|
|
lstrcat(path, CHSEPSTR);
|
|
|
|
lstrcat(path, sz);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Return a pointer to the file name part of a string
|
|
*/
|
|
|
|
LPTSTR FileName(LPTSTR szPath)
|
|
{
|
|
LPTSTR sz;
|
|
|
|
for (sz=szPath; *sz; sz++)
|
|
;
|
|
|
|
for (; sz>=szPath && !SLASH(*sz) && *sz!=TEXT(':'); sz--)
|
|
;
|
|
|
|
return ++sz;
|
|
}
|
|
|
|
/*
|
|
* Return the portion of a file name following the disk (ie anything
|
|
* before the colon).
|
|
* If there is no colon just return a pointer to the original string
|
|
*/
|
|
|
|
LPTSTR RemoveDiskId(LPTSTR szPath)
|
|
{
|
|
LPTSTR sz;
|
|
|
|
for (sz = szPath; *sz; sz++) {
|
|
if (*sz == TEXT(':')) {
|
|
return sz + 1;
|
|
}
|
|
}
|
|
|
|
return szPath;
|
|
}
|
|
|
|
LPTSTR StripPathName(LPTSTR szPath)
|
|
{
|
|
LPTSTR sz;
|
|
|
|
sz = FileName(szPath);
|
|
|
|
if (sz > szPath+1 && SLASH(sz[-1]) && sz[-2] != TEXT(':'))
|
|
sz--;
|
|
|
|
*sz = 0;
|
|
return szPath;
|
|
}
|
|
|
|
/*
|
|
* See if a file is a kernel driver. Unfortunately the VersionInfo APIs
|
|
* don't seem coded up to take care of this at the moment so we just check
|
|
* to see if the file extension is ".SYS"
|
|
*/
|
|
|
|
BOOL IsFileKernelDriver(LPTSTR szPath)
|
|
{
|
|
TCHAR drive[MAX_PATH];
|
|
TCHAR dir[MAX_PATH];
|
|
TCHAR fname[MAX_PATH];
|
|
TCHAR ext[MAX_PATH];
|
|
|
|
lsplitpath(szPath, drive, dir, fname, ext);
|
|
return !_wcsicmp(ext, TEXT(".sys"));
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
*
|
|
* This function converts returned flags from Ver API to the numerical
|
|
* error codes used in SETUP.
|
|
*
|
|
***************************************************************************/
|
|
|
|
UINT ConvertFlagToValue(DWORD dwFlags)
|
|
{
|
|
if ( ! dwFlags )
|
|
return(NO_ERROR);
|
|
if ( dwFlags & VIF_CANNOTREADSRC )
|
|
return(ERROR_FILE_NOT_FOUND);
|
|
if ( dwFlags & VIF_OUTOFMEMORY )
|
|
return(ERROR_OUTOFMEMORY);
|
|
if ( dwFlags & VIF_ACCESSVIOLATION )
|
|
return(ERROR_ACCESS_DENIED);
|
|
if ( dwFlags & VIF_SHARINGVIOLATION )
|
|
return(ERROR_SHARING_VIOLATION);
|
|
if ( dwFlags & VIF_FILEINUSE)
|
|
return(FC_ERROR_LOADED_DRIVER);
|
|
|
|
return(ERROR_CANNOT_COPY); // General error
|
|
}
|
|
|
|
|
|
|
|
#ifdef CHECK_FLOPPY
|
|
/*--------------------------------------------------------------------------
|
|
|
|
IsValidDiskette() -
|
|
|
|
--------------------------------------------------------------------------*/
|
|
|
|
#define CBSECTORSIZE 512
|
|
#define INT13_READ 2
|
|
|
|
BOOL IsValidDiskette(int iDrive)
|
|
{
|
|
TCHAR buf[CBSECTORSIZE];
|
|
|
|
iDrive |= 0x0020; // make lower case
|
|
|
|
iDrive -= 'a'; // A = 0, B = 1, etc. for BIOS stuff
|
|
|
|
return MyReadWriteSector(buf, INT13_READ, iDrive, 0, 0, 1);
|
|
}
|
|
|
|
|
|
|
|
/* BOOL IsDiskInDrive(char cDisk)
|
|
*
|
|
* Is the specifed disk in the drive
|
|
*
|
|
* ENTRY:
|
|
*
|
|
* cDisk : what disk required to be in the drive (logical)
|
|
*
|
|
* return TRUE if the specifed disk is in the drive
|
|
* FALSE if the wrong disk is in the drive or disk error
|
|
*
|
|
*/
|
|
BOOL IsDiskInDrive(int iDisk)
|
|
{
|
|
|
|
if ((iDisk >= 'A' && iDisk <= 'Z') ||
|
|
(iDisk >= 'a' && iDisk <= 'z'))
|
|
{
|
|
if (DosRemoveable(iDisk))
|
|
{
|
|
if (!IsValidDiskette(iDisk))
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
return TRUE; // for non drive letters assume a path
|
|
// and thus always in.
|
|
}
|
|
|
|
#endif
|