windows-xp/Source/XPSP1/NT/base/ntsetup/legacy/dll/copy.c

#include "precomp.h"
#pragma hdrstop
/* File: filecm.c */
/*************************************************************************
**  Install: File Copying commands.
**************************************************************************/

extern HWND   hwndFrame;
extern HANDLE hinstShell;

extern HWND hwndProgressGizmo;
extern CHP rgchBufTmpLong[];


/* Globals */
CHP szFullPathSrc[cchpFullPathBuf] = "\0";
CHP szFullPathDst[cchpFullPathBuf] = "\0";
CHP szFullPathBak[cchpFullPathBuf] = "\0";

CHAR GaugeText1[50], GaugeText2[50];
BOOL fNTUpgradeSetup,fInitialSetup;

SZ APIENTRY SzGetSrcDollar(SZ szFullPathSrc,CHAR ch);

PSTR LOCAL_SOURCE_DIRECTORY = "\\$WIN_NT$.~LS";

int
DetermineDriveType(
    IN CHAR DriveLetter
    );

BOOL
FGetFileSecurity(
    PCHAR File,
    PSECURITY_DESCRIPTOR *SdBuf,
    CB *SdLen
    );

BOOL
FSetFileSecurity(
    PCHAR File,
    PSECURITY_DESCRIPTOR SdBuf
    );

VOID
ValidateAndChecksumFile(
    IN  PSTR     Filename,
    OUT PBOOLEAN IsNtImage,
    OUT PULONG   Checksum,
    OUT PBOOLEAN Valid
    );

BOOL
DoesFileReplaceThirdPartyFile(
    SZ  szFullPathDst
    );


/*
**  Purpose:
**      Copies all files in the current copy list and resets the list to
**      empty.  Copying is sorted by source disk to limit potential disk
**      swapping.
**  Arguments:
**      hInstance:  non-NULL instance handle for getting strings from
**          resources for SwapDisk message Box.
**  Returns:
**      Returns fTrue if all copies successful, fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY FCopyFilesInCopyList(hInstance)
HANDLE hInstance;
{
    DID             did;
    PCLN            pclnCur;
    PPCLN           ppclnPrev;
    LONG            lTotalSize;
    PPCLN           ppclnHead;
    PPPCLN          pppclnTail;
    PSDLE           psdle;
    BOOL            fSilentSystem = FGetSilent();
    UINT            fuModeSav;
    PINFPERMINFO    pPermInfo;
    PSDLE           psdleGlobalHead = (PSDLE)NULL;
    PSDLE           psdleGlobalEnd  = (PSDLE)NULL;
    PSDLE           psdleGlobal;
    DID             didGlobalCur;
    BOOL            fCopyStatus = fFalse;
    SZ              sz;


    if(!InitDiamond()) {
        return(fFalse);
    }

    fInitialSetup = fFalse;
    fNTUpgradeSetup = fFalse;

    if (!fSilentSystem) {
        ProOpen(hwndFrame, 0);
        ProSetBarRange(10000);
    }

    //
    // Determine if we are in initial setup
    //

    if ((sz = SzFindSymbolValueInSymTab("!STF_INSTALL_TYPE")) != (SZ)NULL &&
        (CrcStringCompareI(sz, "SETUPBOOTED") == crcEqual)) {

        fInitialSetup = fTrue;
    }

    //
    // Determine if we are an NT upgrade setup
    //

    if (fInitialSetup
        && (sz = SzFindSymbolValueInSymTab("!STF_NTUPGRADE")) != (SZ)NULL
        && (CrcStringCompareI(sz, "YES") == crcEqual)) {

        fNTUpgradeSetup = fTrue;
    }

    //
    // Go through all the disk media descriptions and assign universal
    // ids for all source media.  This is necessary because two infs
    // may refer to the same disk using different ids.
    //

    pPermInfo    = pInfPermInfoHead;
    didGlobalCur = didMin;
    while ( pPermInfo ) {

        //
        // If the INF has a source media description list, go through list
        //

        psdle = pPermInfo->psdleHead;
        while ( psdle ) {

            //
            // search all the global psdles for a match with the current
            // disk.  search based on disk label ( which is hopefully unique )
            //

            psdleGlobal     = psdleGlobalHead;
            while ( psdleGlobal ) {
                if( !CrcStringCompareI( psdleGlobal->szLabel, psdle->szLabel ) ) {
                    break;
                }
                psdleGlobal     = psdleGlobal->psdleNext;
            }

            if ( psdleGlobal == NULL ) {
                PSDLE   psdleNew;
                if ((psdleNew = PsdleAlloc()) == (PSDLE)NULL ||
                    (psdleNew->szLabel   = SzDupl(psdle->szLabel))  == (SZ)NULL ||
                    (psdle->szTagFile != NULL && ((psdleNew->szTagFile = SzDupl(psdle->szTagFile)) == (SZ)NULL)) ||
                    (psdle->szNetPath != NULL && ((psdleNew->szNetPath = SzDupl(psdle->szNetPath)) == (SZ)NULL))) {
                    goto CopyFailed;
                }
                psdleNew->psdleNext = (PSDLE)NULL;
                if ( !psdleGlobalHead ) {
                    psdleGlobalHead = psdleGlobalEnd  = psdleNew;
                }
                else {
                    psdleGlobalEnd->psdleNext = psdleNew;
                    psdleGlobalEnd            = psdleNew;
                }
                psdleGlobal = psdleNew;
                psdleGlobal->didGlobal = didGlobalCur++;
            }
            psdle->didGlobal = psdleGlobal->didGlobal;
            psdle = psdle->psdleNext;
        }
        pPermInfo = pPermInfo->pNext;
    }

    //
    // Go through the copy list of all infs and calculate total copy
    // list cost
    //

    pPermInfo  = pInfPermInfoHead;
    lTotalSize = 0L;
    while ( pPermInfo ) {

        //
        //  If the INF has a source media description list, look at the
        //  copy list
        //

        if ( pPermInfo->psdleHead ) {

            Assert(FValidCopyList( pPermInfo ));

            ppclnHead  = PpclnHeadList( pPermInfo );
            pppclnTail = PppclnTailList( pPermInfo );

#if DBG
            *pppclnTail = NULL;   /* for FValidCopyList() calls */
#endif
            pclnCur    = *ppclnHead;
            //
            //  Traverse the copy list and determine the total size of the
            //  files to copy.
            //
            while (pclnCur != (PCLN)NULL) {

                if (pclnCur->psfd->oer.ctuCopyTime > 0) {
                    lTotalSize += pclnCur->psfd->oer.ctuCopyTime;
                } else {
                    lTotalSize += pclnCur->psfd->oer.lSize;
                }
                pclnCur = pclnCur->pclnNext;
            }
        }
        pPermInfo = pPermInfo->pNext;
    }

    if (lTotalSize == 0L) {
        lTotalSize = 1L;
    }

    //
    //  Show gauge stuff if not in silent mode.
    //

    if (!fSilentSystem) {

        SZ  szText;

        ProSetBarPos(0);

        szText = SzFindSymbolValueInSymTab("ProText1");
        if( szText ) {
            strcpy(GaugeText1, szText);
        }
        else {
            strcpy(GaugeText1, "");
        }

        szText = SzFindSymbolValueInSymTab("ProText2");
        if( szText ) {
            strcpy(GaugeText2, szText);
        }
        else {
            strcpy(GaugeText2, "");
        }


        ProSetText(ID_STATUS3, "");
        ProSetText(ID_STATUS4, "");
    }


    //
    // Copy the files
    //

    psdleGlobal = psdleGlobalHead;
    while (psdleGlobal ) {

        didGlobalCur = psdleGlobal->didGlobal;
        pPermInfo  = pInfPermInfoHead;
        while ( pPermInfo ) {

            //
            // Verify that this INF has a copy list
            //

            if ((psdle = pPermInfo->psdleHead) == (PSDLE)NULL ) {
                Assert( !*PpclnHeadList( pPermInfo ) );
                pPermInfo = pPermInfo->pNext;
                continue;
            }
            Assert(FValidCopyList( pPermInfo ));

            //
            // If it does, go through its source media descriptions finding
            // all disks that match the current global disk id and copy all
            // files which are described by the disks found
            //

            while ( psdle ) {

                if( psdle->didGlobal != didGlobalCur ) {
                    psdle = psdle->psdleNext;
                    continue;
                }
                did = psdle->did;

                ppclnHead  = PpclnHeadList( pPermInfo );
                pppclnTail = PppclnTailList( pPermInfo );

#if DBG
                *pppclnTail = NULL;   /* for FValidCopyList() calls */
#endif
                ppclnPrev        = ppclnHead;
                pclnCur          = *ppclnHead;

                //
                //  Now traverse the copy list, copying all
                //  the files that match the disk id
                //

                while (pclnCur != (PCLN)NULL) {

                    if ( (pclnCur->psfd->did != did) ||
                         (pclnCur->psfd->InfId != pPermInfo->InfId ) ) {
                        ppclnPrev = &(pclnCur->pclnNext);
                        pclnCur   = pclnCur->pclnNext;
                        continue;
                    }


                    fuModeSav = SetErrorMode(
                                   SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX
                                   );

                    if(!FCopyListFile(hInstance,pclnCur,psdle,lTotalSize)) {

                        SetErrorMode(fuModeSav);
                        goto CopyFailed;
                    }

                    SetErrorMode(fuModeSav);

                    //
                    //  File copied, delete its entry from the copy list
                    //
                    *ppclnPrev = pclnCur->pclnNext;
                    EvalAssert(FFreePcln(pclnCur));
                    pclnCur = *ppclnPrev;

                    Assert(FValidCopyList( pPermInfo ));
                }

                psdle = psdle->psdleNext;
            }
            pPermInfo = pPermInfo->pNext;
        }
        psdleGlobal = psdleGlobal->psdleNext;
    }
    if (!fSilentSystem) {
        ProSetBarPos(10000 - 1);
    }
    fCopyStatus = fTrue;

CopyFailed:

    if (!fSilentSystem) {
        ProClose(hwndFrame);
        UpdateWindow(hwndFrame);
    }

    pPermInfo    = pInfPermInfoHead;
    while ( pPermInfo ) {
        EvalAssert(FFreeCopyList( pPermInfo ));
        pPermInfo = pPermInfo->pNext;
    }

    psdleGlobal = psdleGlobalHead;
    while ( psdleGlobal ) {
        PSDLE psdleNext = psdleGlobal->psdleNext;
        FFreePsdle( psdleGlobal );
        psdleGlobal = psdleNext;
    }

    TermDiamond();
    RestoreDiskLoggingDone();

    return(fCopyStatus);

}



/*
**  Purpose:
**      To determine if the given file is read only.
**  Arguments:
**      szFullPathDst : a non-Null, zero-terminated string containing the fully
**          qualified valid path (including the drive) to the file in
**          question.  File must exist.
**  Returns:
**      ynrcYes if the file is read only, ynrcNo otherwise.
**
**************************************************************************/
YNRC APIENTRY YnrcFileReadOnly(szFullPathDst)
SZ szFullPathDst;
{
    BOOL     fOkay = fTrue;
    unsigned uiAttrib;

    ChkArg(szFullPathDst != (SZ)NULL && FValidPath(szFullPathDst) &&
            FFileFound(szFullPathDst), 1, ynrcErr1);

    if ((uiAttrib = GetFileAttributes(szFullPathDst)) == -1)
        fOkay = fFalse;

    if (!fOkay)
        return(ynrcErr1);

    return((uiAttrib & FILE_ATTRIBUTE_READONLY) ? ynrcYes : ynrcNo);
}


/*
**  Purpose:
**      To set the read only status of a file to either read only or normal.
**  Arguments:
**      szFullPathDst:  a non-Null, zero-terminated string containing the fully
**          qualified valid path (including drive) whose status is to be
**          set.  File must already exist.
**      fReadOnly:      fTrue if the status is to be set to read only, fFalse
**          if the status is to be set to normal
**  Returns:
**      fTrue if the function succeeds in setting the status as specified,
**      fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY FSetFileReadOnlyStatus(SZ szFullPathDst,BOOL fReadOnly)
{
    BOOL  fRet = fFalse;
    DWORD uiAttrib;
    DWORD newAttrib;

    ChkArg(szFullPathDst != (SZ)NULL && FValidPath(szFullPathDst) &&
            FFileFound(szFullPathDst), 1, fFalse);

    if ((uiAttrib = GetFileAttributes(szFullPathDst)) != -1) {

        if(fReadOnly) {
            newAttrib = uiAttrib | FILE_ATTRIBUTE_READONLY;
        } else {
            newAttrib = uiAttrib & ~FILE_ATTRIBUTE_READONLY;
        }

        if((newAttrib == uiAttrib) || SetFileAttributes(szFullPathDst, newAttrib)) {
            fRet = fTrue;
        }
    }

    return(fRet);
}


/*
**  Purpose:
**      To determine if there is already a destination file that is "newer" than
**      the source file.
**  Arguments:
**      dateSrc: valid date value in unsigned int form extracted from INF.
**      szFullPathDst: a non-Null, zero terminated string containing the fully
**          qualified valid path (including disk drive) to the destination
**          file.  File must exist.
**      dwVerSrcMS: Most significant 32 bits of source file version stamp.
**      dwVerSrcLS: Least significant 32 bits of source file version stamp.
**  Returns:
**      ynrcYes if the destination file already exists and is newer than
**          the source file.
**      ynrcErr1, ynrcErr2, or ynrcErr3 in errors.
**      ynrcNo otherwise.
**
**************************************************************************/
YNRC APIENTRY YnrcNewerExistingFile(USHORT dateSrc,
        SZ szFullPathDst, DWORD dwVerSrcMS, DWORD dwVerSrcLS)
{
    USHORT   dateDst, timeDst;
    PFH      pfhDst;
    FILETIME WriteTime;
    DWORD    dwVerDstMS;
    DWORD    dwVerDstLS;


    ChkArg(szFullPathDst != (SZ)NULL && FValidPath(szFullPathDst) &&
            FFileFound(szFullPathDst), 2, ynrcErr1);


    if ( (dwVerSrcMS != 0L || dwVerSrcLS != 0L) &&
         FGetFileVersion(szFullPathDst, &dwVerDstMS, &dwVerDstLS)) {

        if (dwVerDstMS > dwVerSrcMS  ||
            (dwVerDstMS == dwVerSrcMS && dwVerDstLS > dwVerSrcLS)) {

            return(ynrcYes);
        }
        else {
            return(ynrcNo);
        }

    }
    else {
        if ((pfhDst = PfhOpenFile(szFullPathDst, ofmRead)) == NULL) {
            return(ynrcErr1);
        }

        if (!GetFileTime((HANDLE)LongToHandle(pfhDst->iDosfh), NULL, NULL, &WriteTime) ||
            !FileTimeToDosDateTime(&WriteTime, &dateDst, &timeDst)) {

            FCloseFile(pfhDst);
            return(ynrcErr2);
        }

        if (!FCloseFile(pfhDst)) {
            return(ynrcErr3);
        }

        if (dateDst > dateSrc) {
            return(ynrcYes);
        }
    }

    return(ynrcNo);
}

/*
**  Purpose:
**      Gets the file version values from the given file and sets the
**      given pdwMS/pdwLS variables.
**  Arguments:
**      szFullPath: a zero terminated character string containing the fully
**          qualified path (including disk drive) to the file.
**      pdwMS: Most significant 32 bits of source file version stamp.
**      pdwLS: Least significant 32 bits of source file version stamp.
**  Returns:
**      fTrue if file and file version resource found and retrieved,
**      fFalse if not.
+++
**  Implementation:
**************************************************************************/
BOOL APIENTRY FGetFileVersion(szFullPath, pdwMS, pdwLS)
SZ      szFullPath;
DWORD * pdwMS;
DWORD * pdwLS;
{
    BOOL  fRet = fFalse;
    DWORD dwHandle;
    DWORD dwLen;
    LPSTR lpData;

    ChkArg(szFullPath != (SZ)NULL,       1, fFalse);
    ChkArg(pdwMS      != (DWORD *)NULL,  2, fFalse);
    ChkArg(pdwLS      != (DWORD *)NULL,  3, fFalse);

    //
    // Get the file version info size
    //

    if ((dwLen = GetFileVersionInfoSize((LPSTR)szFullPath, &dwHandle)) == 0) {
        return (fRet);
    }

    //
    // Allocate enough size to hold version info
    //

    while ((lpData = (LPSTR)SAlloc((CB)dwLen)) == (LPSTR)NULL) {
        if (!FHandleOOM(hwndFrame)) {
            return (fRet);
        }
    }

    //
    // Get the version info
    //

    fRet = GetFileVersionInfo((LPSTR)szFullPath, dwHandle, dwLen, lpData);

    if (fRet) {
        VS_FIXEDFILEINFO *pvsfi;
        DWORD            dwLen;

        fRet = VerQueryValue(
                   (LPVOID)lpData,
                   (LPSTR)"\\",
                   (LPVOID *)&pvsfi,
                   &dwLen
                   );

        if (fRet) {
            *pdwMS = pvsfi->dwFileVersionMS;
            *pdwLS = pvsfi->dwFileVersionLS;
        }
    }

    SFree(lpData);
    return (fRet);


}

/*
**  Purpose:
**      Renames the given destination file as a backup file based on
**      the backup file name given.  If a backup file with the given
**      name already exists, the function does nothing and returns.
**  Arguments:
**      szDst:    a zero terminated  char string containing the fully
**          qualified path to the file to be backed up.
**      szBackup: a zero terminated char string containing the file name
**          of the file that will be the backup copy of szDst.  This is
**          not a fully qualified path, or subpath, it is only the filename
**          (i.e. primary.ext).
**      psfd:     pointer to the Section-File Description(SFD) structure of
**          the file being backed up.
**  Returns:
**      ynrcNo:   if the backup file name is invalid or if unable to create
**          the backup and user chooses to abort.
**      ynrcErr1: if unable to create the backup and the user chooses ignore.
**      ynrcYes:  if the backup is successfully created or already exists.
**
**************************************************************************/
YNRC APIENTRY YnrcBackupFile(szDst, szBackup, psfd)
SZ   szDst;
SZ   szBackup;
PSFD psfd;
{
    YNRC ynrcRet = ynrcYes;

    Unused(szBackup);

    Assert(psfd->oer.szAppend == (SZ)NULL);

    if (!FBuildFullBakPath(szFullPathBak, szDst, psfd) ||
            !FValidPath(szFullPathBak))
        return(ynrcNo);

    /* If the backup file already exists, leave the existing backup
    ** and return.  (Either the user made it and we don't want to kill
    ** his, or we made it and we don't need to make another one.)
    */
    if (FFileFound(szFullPathBak))
        return(ynrcYes);

    while (rename(szFullPathDst, szFullPathBak))
        {
        EERC eerc;

        if ((eerc = EercErrorHandler(hwndFrame, grcRenameFileErr,
                psfd->oer.oef & oefVital, szFullPathDst, szFullPathBak, 0))
                == eercAbort)
            {
            ynrcRet = ynrcNo;
            break;
            }
        else if (eerc == eercIgnore)
            {
            ynrcRet = ynrcErr1;
            break;
            }
        Assert(eerc == eercRetry);
        }

    return(ynrcRet);
}


/*
**************************************************************************/
USHORT APIENTRY DateFromSz(SZ sz)
{
    USHORT usAns, usYear, usMonth, usDay;

    ChkArg(sz == (SZ)NULL || FValidOerDate(sz), 1, 0);

    if (sz == (SZ)NULL)
        {
        usYear  = 1980;
        usMonth = 1;
        usDay   = 1;
        }
    else
        {
        usYear  = (USHORT)atoi(sz);
        usMonth = (USHORT)atoi(sz + 5);
        usDay   = (USHORT)atoi(sz + 8);
        }

    Assert(usYear  >= 1980 && usYear  <= 2099);
    Assert(usMonth >= 1    && usMonth <= 12);
    Assert(usDay   >= 1    && usDay   <= 31);

    usAns = usDay + (usMonth << 5) + ((usYear - (USHORT)1980) << 9);

    return(usAns);
}


BOOL
CreateTargetAsLinkToMaster(
   IN SZ FullSourceFilename,
   IN SZ FullTargetFilename,
   IN BOOL TargetExists
   )
{
    //BUGBUG: handle case of target file in use.
    //BUGBUG: handle case of target already exists.
    //BUGBUG: handle owm modes

    //BUGBUG: The following code is written to work with the prototype COW
    //        server, not with the real SIS server.  If the target file
    //        exists, we assume it is the correct version (in the master
    //        tree) and don't do the copy.
    //
    if ( TargetExists ) {
        //DbgPrint( "SIS: Target %s exists; not copying\n", FullTargetFilename );
        return NO_ERROR;            // target exists; don't copy
    }
    //DbgPrint( "SIS: Target %s doesn't exist; copying\n", FullTargetFilename );
    return ERROR_FILE_NOT_FOUND;    // target doesn't exist; copy by usual means
}


/*
**  Purpose:
**      Performs the copy defined by the given copy list node.
**  Arguments:
**      hInstance:  non-NULL instance handle for getting strings from
**          resources for SwapDisk message Box.
**      pcln:       pointer to the Copy List Node (CLN) of the file to be
**          copied.
**      psdle:      non-NULL Source-Description-List-Element pointer to be
**          used by FPromptForDisk().
**      lTotalSize: the total of all of the sizes (i.e. oer.ctuCopyTime or
**          oer.lSize) for all of the files on the disk currently being copied.
**  Returns:
**      fTrue if the copy was successful, fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY
FCopyListFile(
    HANDLE hInstance,
    PCLN   pcln,
    PSDLE  psdle,
    LONG   lTotalSize
    )
{
    PSFD   psfd = pcln->psfd;
    POER   poer = &(psfd->oer);
    BOOL   fDstExists, fCompressedName;
    SZ     szSrcDollar = NULL;
    BOOL   fVital = poer->oef & oefVital;
    EERC   eerc;
    int    Removable;
    LONG   lSize;
    USHORT dateSrc = DateFromSz(poer->szDate);
    PSECURITY_DESCRIPTOR Sd = NULL;
    CB     SdLen;
    CHP    szNonCompressedFullPathSrc[cchpFullPathBuf] = "\0";
    SZ     SymbolValue;
    CHAR   szSrcDrive[10];

    ChkArg(pcln  != (PCLN)NULL,  1, fFalse);
    ChkArg(psdle != (PSDLE)NULL, 2, fFalse);

    //
    // Only if a drive is removable do we check for the tagfile, in the case
    // of a net drive the error is caught later on when we look for the src
    // file.  Note that the tag file is relative to the root of the removable
    // drive.
    //
    // Because of a bug in 3.51 there are CD's which expect the tagfile to be
    // locatable in a subdirectory. We'll use a hack based on STF_CWDDIR
    // to make that work.
    //
    Removable = DetermineDriveType(*(pcln->szSrcDir));
    if((Removable < 0) && psdle->szTagFile) {

        strcpy(szSrcDrive,"?:\\");
        szSrcDrive[0] = *(pcln->szSrcDir);

        if(!FBuildFullSrcPath(szFullPathSrc,szSrcDrive,psdle->szTagFile,NULL)) {
            EercErrorHandler(hwndFrame,grcInvalidPathErr,fVital,szSrcDrive,psdle->szTagFile,0);
            return(!fVital);
        }

        if((Removable == -2) && (SymbolValue = SzFindSymbolValueInSymTab("!STF_CWDDIR"))) {
            if(!FBuildFullSrcPath(szFullPathDst,SymbolValue,psdle->szTagFile,NULL)) {
                szFullPathDst[0] = 0;
            }
        } else {
            szFullPathDst[0] = 0;
        }

        //
        // Strip the backslash off the drive letter.
        //
        szSrcDrive[2] = '\0';

        //
        // If we can't find the tag file at the root then also look in
        // STF_CWDDIR, if there is one.
        //
        while(!FFileFound(szFullPathSrc) && (!szFullPathDst[0] || !FFileFound(szFullPathDst))) {

            MessageBeep(0);
            ShowOwnedPopups(hwndFrame,FALSE);
            if(FPromptForDisk(hInstance, psdle->szLabel, szSrcDrive)) {
                ShowOwnedPopups(hwndFrame,TRUE);
            } else {

                HWND hwndSav = GetFocus();
                BOOL b;
                CCHL szTmpText[cchpBufTmpLongMax];

                //
                // Make sure this is what he *really* wants to do.
                //

                LoadString(hInstance, IDS_SURECANCEL, rgchBufTmpLong, cchpBufTmpLongMax);
                LoadString(hInstance, IDS_ERROR, (LPSTR)szTmpText, cchpBufTmpLongMax);
                b = (MessageBox(hwndFrame, rgchBufTmpLong, (LPSTR)szTmpText, MB_YESNO|MB_TASKMODAL) == IDYES);
                ShowOwnedPopups(hwndFrame,TRUE);
                SetFocus(hwndSav);
                SendMessage(hwndFrame, WM_NCACTIVATE, 1, 0L);
                if(b) {
                    return(fFalse);
                }
            }
        }
    }


    if (!FBuildFullSrcPath(szFullPathSrc, pcln->szSrcDir, psfd->szFile,
            (Removable < 0) ? NULL : psdle->szNetPath)) {
        EvalAssert(EercErrorHandler(hwndFrame, grcInvalidPathErr, fVital,
                pcln->szSrcDir, psfd->szFile, 0) == eercAbort);
        return(!fVital);
    }

    //
    // Determine the source file name:
    // Check to see if source file exists as the regular name or
    // a compressed name
    //

    lstrcpy( szNonCompressedFullPathSrc, szFullPathSrc );
    fCompressedName = fFalse;
    while (!FFileFound( szFullPathSrc )) {
        if (szSrcDollar == (SZ)NULL) {
            while ((szSrcDollar = SzGetSrcDollar(szFullPathSrc,'_')) == (SZ)NULL) {
                if (!FHandleOOM(hwndFrame)) {
                    return(!fVital);
                }
            }
        }

        if (FFileFound( szSrcDollar )) {
            lstrcpy( szFullPathSrc, szSrcDollar );
            fCompressedName = fTrue;
            break;
        }

#define DOLLAR_NAME
#ifdef DOLLAR_NAME
        SFree(szSrcDollar);
        while((szSrcDollar = SzGetSrcDollar(szFullPathSrc,'$')) == (SZ)NULL) {
            if (!FHandleOOM(hwndFrame)) {
                return(!fVital);
            }
        }
        if(FFileFound(szSrcDollar)) {
            lstrcpy(szFullPathSrc,szSrcDollar);
            fCompressedName = fTrue;
            break;
        }
#endif

        SFree( szSrcDollar);
        szSrcDollar = NULL;

        //
        // Unable to locate the source file.
        // If we are supposed to skip missing files, ignore it.
        // Text setup sets a symbol called SMF to YES if we are
        // supposed to skip missing files.
        //
        if((SymbolValue = SzFindSymbolValueInSymTab("!SMF")) && !lstrcmpi(SymbolValue,"YES")) {
            return(fTrue);
        }

        //
        // If the file exists on the target and this is a winnt
        // non-upgrade setup, just assume the file was already copied.
        //
        if(/*fInitialSetup &&*/ !fNTUpgradeSetup
        && !_strnicmp(szFullPathSrc+2,LOCAL_SOURCE_DIRECTORY,lstrlen(LOCAL_SOURCE_DIRECTORY)))
        {
            if(!FBuildFullDstPath(szFullPathDst, pcln->szDstDir, psfd, FALSE)) {
                if (!FHandleOOM(hwndFrame)) {
                    return(!fVital);
                }
            }

            if(FFileExists(szFullPathDst)) {
                return(fTrue);
            }
        }

        if ((eerc = EercErrorHandler(hwndFrame, grcOpenFileErr, fVital,
                szFullPathSrc, 0, 0)) != eercRetry) {
            return(eerc == eercIgnore);
        }

    }
    if (szSrcDollar) {
        SFree( szSrcDollar);
        szSrcDollar = (SZ)NULL;
    }

    //
    // Determine the destination file name:
    //

    if (!FBuildFullDstPath(szFullPathDst, pcln->szDstDir, psfd, fCompressedName) ||
            !FValidPath(szFullPathDst)) {
        EvalAssert(EercErrorHandler(hwndFrame, grcInvalidPathErr, fVital,
                pcln->szDstDir, psfd->szFile, 0) == eercAbort);
        return(!fVital);
    }

    fDstExists = FFileFound(szFullPathDst);

#ifdef REMOTE_BOOT
    if (1) { //BUGBUG: how to turn on SIS check here?
        DWORD rc;
        if (!fCompressedName) {
            rc = CreateTargetAsLinkToMaster(
                    szFullPathSrc,
                    szFullPathDst,
                    fDstExists
                    );
            if (rc == NO_ERROR) {
                return TRUE;
            }
        }
    }
#endif

    if (fDstExists != fFalse) {
        OWM  owm;
        YNRC ynrc;

        //
        // Check overwrite mode.  The overwrite mode can be:
        //
        // 1. Never      : No further checking.  The file is not copied
        //
        // 2. Unprotected: Check to see if file on destination is readonly.
        //
        // 3. Older      : The release version / date is checked against the
        //                 the destination file
        //
        // 4. VerifySourceOlder: The checking is postponed till we have actually
        //                       found the source file.  The source time is then
        //                       compared against the destination time and only
        //                       if the destination is older the file is copied.

        if ((owm = poer->owm) & owmNever) {

            return(fTrue);

        }
        else if (owm & owmUnprotected) {

            while ((ynrc = YnrcFileReadOnly(szFullPathDst)) == ynrcErr1) {
                if ((eerc = EercErrorHandler(hwndFrame, grcReadFileErr, fVital,
                        szFullPathDst, 0, 0)) != eercRetry) {
                    return(eerc == eercIgnore);
                }
            }

            if (ynrc == ynrcYes) {
                return(fTrue);
            }

        }
        else if (owm & owmOlder) {

            while ((ynrc = YnrcNewerExistingFile(dateSrc, szFullPathDst,
                        poer->ulVerMS, poer->ulVerLS)) != ynrcYes
                    && ynrc != ynrcNo) {
                if (ynrc == ynrcErr1 &&
                        (eerc = EercErrorHandler(hwndFrame, grcOpenFileErr,
                                fVital, szFullPathDst, 0, 0)) != eercRetry)
                    return(eerc == eercIgnore);
                else if (ynrc == ynrcErr2 &&
                        (eerc = EercErrorHandler(hwndFrame, grcReadFileErr,
                                fVital, szFullPathDst, 0, 0)) != eercRetry)
                    return(eerc == eercIgnore);
                else if (ynrc == ynrcErr3 &&
                        (eerc = EercErrorHandler(hwndFrame, grcCloseFileErr,
                                fVital, szFullPathDst, 0, 0)) != eercRetry)
                    return(eerc == eercIgnore);
            }

            if (ynrc == ynrcYes)
                return(fTrue);
            Assert(ynrc == ynrcNo);

        }

    }
    else {

        //
        // Destination doesn't exist, check to see if we are in upgradeonly
        // mode, in which case we need not copy the file and we can just
        // return.

        OEF oef = poer->oef;

        if ( oef & oefUpgradeOnly ) {
            return( fTrue );
        }

    }

    //
    // If destination exists then we need to preserve the security that is
    // there on the file.  We read the security on the existing file
    // and once the new file is copied over then we set the security read
    // on the new file.  Note that we don't do this for initial setup since
    // we are going to fix permissions on the file anyway.
    //

    if(fDstExists && !fInitialSetup) {
        if(!FGetFileSecurity(szFullPathDst, &Sd, &SdLen)) {
            return( fFalse );
        }
    }

    if (fDstExists &&
            poer->szBackup != NULL)
        {
        YNRC ynrc;

        if ((ynrc = YnrcBackupFile(szFullPathDst, poer->szBackup, psfd)) !=
                ynrcYes)
            return(ynrc != ynrcNo);
        fDstExists = FFileFound(szFullPathDst);
        }

    if (fDstExists)
        {
        while (!FSetFileReadOnlyStatus(szFullPathDst, fOff))
            {
            if ((eerc = EercErrorHandler(hwndFrame, grcWriteFileErr, fVital,
                    szFullPathDst, 0, 0)) != eercRetry)
                return(eerc == eercIgnore);
            }
        }

    if(!fSilentSystem) {

        LPSTR p;
        CHAR  chSave;

        EvalAssert((p = SzFindFileFromPath(szFullPathSrc)) != NULL);
        if(!p) {
            p = szFullPathSrc;
        }
        wsprintf(rgchBufTmpLong,"%s %s",GaugeText1,p);
        ProSetText(ID_STATUS1,rgchBufTmpLong);

        EvalAssert((p = SzFindFileFromPath(szFullPathDst)) != NULL);
        if(p) {
            if(!ISUNC(szFullPathDst) && (p - szFullPathDst != 3)) {    // account for file in root
                p--;
            }
            chSave = *p;
            *p = '\0';
            wsprintf(rgchBufTmpLong,"%s %s",GaugeText2,szFullPathDst);
            *p = chSave;
        } else {
            rgchBufTmpLong[0] = '\0';
        }
        ProSetText(ID_STATUS2,rgchBufTmpLong);
    }

    lSize = (poer->ctuCopyTime > 0) ? (LONG)(poer->ctuCopyTime) : poer->lSize;
    if (!FCopy(szFullPathSrc, szFullPathDst, poer->oef, poer->owm,
            (poer->szAppend != NULL),
            (int)((DWORD)10000 * lSize / lTotalSize), dateSrc,psdle,szNonCompressedFullPathSrc))
        return(fFalse);

    if( Sd ) {
        //
        //    BUGBUG -
        //
        //  Preservation of file security is broken, since the most files
        //  were overwritten during textmode setup.
        //  So this is currently disabled.
        //
        // BOOL Status;
        // Status = FSetFileSecurity(szFullPathDst, Sd);
        SFree(Sd);
        // return(Status);
    }

    return(fTrue);
}


/*
**  Purpose:
**      Uses the Compression DollarSign translation algorithm on its argument.
**      If the file has no extension, then '._' is added.  If the extension
**      has less than 3 characters, then a '_' is appended.  Otherwise, the
**      third character of the extension is replaced by a dollarsign.
**  Arguments:
**      szFullPathSrc:  a zero terminated character string containing the fully
**          qualified path (including drive) for the source file.
**  Returns:
**
**************************************************************************/
SZ APIENTRY SzGetSrcDollar(SZ szFullPathSrc,CHAR ch)
{
    SZ szDot = (SZ)NULL;
    SZ szCur = szFullPathSrc;
    CHAR dotch[3];

    dotch[0] = '.';
    dotch[1] = ch;
    dotch[2] = 0;

    ChkArg(szFullPathSrc != (SZ)NULL, 1, (SZ)NULL);

    while (*szCur != '\0')
        {
        if (*szCur == '.')
            szDot = szCur;
        else if (*szCur == '\\')
            szDot = (SZ)NULL;
        szCur = SzNextChar(szCur);
        }

    Assert(szDot == (SZ)NULL || *szDot == '.');
    if (szDot == (SZ)NULL)
        {
        if ((szDot = (SZ)SAlloc(strlen(szFullPathSrc) + 3)) != (SZ)NULL)
            {
            EvalAssert(strcpy(szDot, szFullPathSrc) == szDot);
            EvalAssert(SzStrCat(szDot, dotch) == szDot);
            }
        }
    else
        {
        CHP chpSav = '\0';
        SZ  szRest;
        CB  cb;

        if (*(szCur = ++szDot) != '\0' &&
                *(szCur = SzNextChar(szCur)) != '\0' &&
                *(szCur = SzNextChar(szCur)) != '\0')
            {
            chpSav = *szCur;
            szRest = SzNextChar(szCur);
            *szCur = '\0';
            }

        cb = strlen(szFullPathSrc) + 2;
        if (chpSav != '\0')
            {
            Assert(szRest != (SZ)NULL);
            cb += strlen(szRest);
            }

        if ((szDot = (SZ)SAlloc(cb)) != (SZ)NULL)
            {
            EvalAssert(strcpy(szDot, szFullPathSrc) == szDot);
            EvalAssert(SzStrCat(szDot, &dotch[1]) == szDot);

            if (chpSav != '\0')
                {
                Assert(szRest != (SZ)NULL);
                EvalAssert(SzStrCat(szDot, szRest) == szDot);
                *szCur = chpSav;
                }
            }
        }

    return(szDot);
}

static int iTickMax = 0;
static int iTickCur = 0;

int far WFromW(int iTick)
{
    if (iTick > iTickMax - iTickCur)
        iTick = iTickMax - iTickCur;

    if (iTick > 0)
        {
        ProDeltaPos(iTick);
        iTickCur += iTick;
        }

    return(1);
}


/*
**  Purpose:
**      To physically copy the source file to the destination file.  This
**      can include several options including appending, open and closing src
**      and dst files, but not actually copying the contents of the files,
**      decompressing, timestamping the dst file, and setting the read only
**      status of the dst file.
**  Arguments:
**      szFullPathSrc:  a zero terminated character string containing the fully
**          qualified path (including drive) for the source file.
**      szFullPathDst: a zero terminated character string containing the fully
**          qualified path (including drive) for the destination file.
**      oef:            option element flags for the Section-File Description
**          The valid flags include oefVital, oefCopy, oefUndo,
**          oefRoot, oefDecompress, oefTimeStamp, oefReadOnly,
**          oefNone and oefAll.
**      fAppend:        fTrue if the contents of szFullPathSrc are to be
**          appended to the contents of szFullPathDst.
**      cProgTicks:     number of ticks to advance Progress Gizmo.
**      dateSrc:        DATE value from INF for src file.
**  Returns:
**      fTrue if the copy is successfully completed, fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY
FCopy(
    SZ szFullPathSrc,
    SZ szFullPathDst,
    OEF oef,
    OWM owm,
    BOOL fAppend,
    int cProgTicks,
    USHORT dateSrc,
    PSDLE psdle,
    SZ szNonCompressedFullPathSrc
    )
{
#if 0
    CB      cbSize;
    CB      cbActual;
#endif
    PB      pbBuffer = NULL;
    PFH     pfhSrc = NULL;
    PFH     pfhDst = NULL;
    LFA     lfaDst = 0L;
    HANDLE  hSource = NULL;
    BOOL    fVital = oef & oefVital;
    BOOL    fDecomp = oef & oefDecompress;
    BOOL    fRet = !fVital;
    BOOL    fRemovePartialFile = fFalse;
    EERC    eerc;
    YNRC    ynrc;
    FILETIME CreateTime, AccessTime, WriteTime;
    BOOL    fSilentSystem = FGetSilent();
    LONG    lRet;
    ULONG   Checksum = 0;
    BOOL    fThirdPartyFile = oef & oefThirdPartyFile;
    BOOL    OnLocalSource;
    BOOLEAN IsValid;
    BOOLEAN IsNtImage;
    BOOL    fCsdInstall = oef & oefCsdInstall;
    SZ      szActiveFileTmpName = NULL;

    if( fCsdInstall &&
        DoesFileReplaceThirdPartyFile( szFullPathDst+2 ) ) {
        return( TRUE );
    }

    OnLocalSource = (_strnicmp(szFullPathSrc+2,LOCAL_SOURCE_DIRECTORY,lstrlen(LOCAL_SOURCE_DIRECTORY)) == 0);

    do {
        while ((pfhSrc = PfhOpenFile(szFullPathSrc, ofmRead)) == (PFH)NULL) {

            if ((eerc = EercErrorHandler(hwndFrame, grcOpenFileErr, fVital,
                    szFullPathSrc, 0, 0)) != eercRetry) {
                fRet = (eerc == eercIgnore);
                goto LCopyError;
            }
        }

        while (!GetFileTime((HANDLE)LongToHandle(pfhSrc->iDosfh), &CreateTime, &AccessTime,
                &WriteTime)) {
            if ((eerc = EercErrorHandler(hwndFrame, grcReadFileErr, fVital,
                    szFullPathSrc, 0, 0)) != eercRetry) {
                fRet = (eerc == eercIgnore);
                goto LCopyError;
            }
        }


        if (!(oef & oefCopy))
            {
            if (!FCloseFile(pfhSrc))
                while ((eerc = EercErrorHandler(hwndFrame, grcCloseFileErr, fVital,
                        szFullPathSrc, 0, 0)) != eercRetry)
                    {
                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                    }
            pfhSrc = NULL;

            if (cProgTicks > 0 && !fSilentSystem)
                ProDeltaPos(cProgTicks);

            fRet = fTrue;
            goto DelSrc;
            }

        if(FFileFound(szFullPathDst)) {

            //
            // We need to check if we have been asked to compare actual file times
            //

            if ( owm & owmVerifySourceOlder ) {

                PFH      pfh;
                FILETIME DstWriteTime;
                BOOL     Older = fFalse;

                if ((pfh = PfhOpenFile(szFullPathDst, ofmRead)) != NULL) {

                    if (GetFileTime((HANDLE)LongToHandle(pfh->iDosfh), NULL, NULL, &DstWriteTime)) {

                        if( CompareFileTime( &DstWriteTime, &WriteTime ) == -1 ) {
                            Older = fTrue;
                        }

                    }
                    FCloseFile(pfh);
                }

                if( !Older ) {

                    FCloseFile(pfhSrc);
                    pfhSrc = NULL;

                    if (cProgTicks > 0 && !fSilentSystem)
                        ProDeltaPos(cProgTicks);

                    fRet = fTrue;
                    goto DelSrc;
                }
            }

            //
            // if this is a CSD, then we need to back up the old file in case
            // the copy fails for some reason.  (We also gotta make sure that
            // the files aren't the same, otherwise we'll get a bogus error)
            //
            if( fCsdInstall && lstrcmpi(szFullPathSrc, szFullPathDst) ) {
                //
                // We don't want to back up the file again, if we're retrying
                //
                if(!szActiveFileTmpName) {
                    while(!(szActiveFileTmpName = FRenameActiveFile(szFullPathDst))) {

                        //
                        // Error opening, present critical error to user
                        //

                        if ((eerc = EercErrorHandler(hwndFrame, grcOpenFileErr, fVital,
                            szFullPathDst, 0, 0)) != eercRetry) {

                            fRet = (eerc == eercIgnore);
                            goto LCopyError;
                        }
                    }
                }
            }
        }


        if ((ynrc = YnrcEnsurePathExists(szFullPathDst, fVital, NULL)) != ynrcYes)
            {
            fRet = (ynrc == ynrcErr1);
            goto LCopyError;
            }

        while ((pfhDst = PfhOpenFile(szFullPathDst,
                (OFM)(fAppend ? ofmReadWrite : ofmCreate))) == NULL) {

            DWORD dw;

            dw = GetLastError();

            //
            // if it is a sharing violation and this is because both the source
            // and destination are the same, then present the error to the user.
            //

            if (dw == ERROR_SHARING_VIOLATION && !lstrcmpi(szFullPathSrc, szFullPathDst)) {
                if ((eerc = EercErrorHandler(hwndFrame, grcOpenSameFileErr, fFalse,
                    szFullPathDst, 0, 0)) != eercRetry) {

                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                }
                else {
                    continue;
                }
            }

            //
            // For active files access will be denied
            //

            if(((dw == ERROR_ACCESS_DENIED) || (dw == ERROR_SHARING_VIOLATION) || (dw == ERROR_USER_MAPPED_FILE))
            && !fAppend) {
                //
                // make sure we don't already have a backup (if this is a retry)
                //
                if((szActiveFileTmpName) || (szActiveFileTmpName = FRenameActiveFile(szFullPathDst))) {
                    continue;
                }
            }

            //
            // Error opening, present critical error to user
            //

            if ((eerc = EercErrorHandler(hwndFrame, grcOpenFileErr, fVital,
                szFullPathDst, 0, 0)) != eercRetry) {

                fRet = (eerc == eercIgnore);
                goto LCopyError;
            }

        }

        fRemovePartialFile = fTrue;

        if (fAppend) {
            USHORT dateDst, timeDst;

            while(!GetFileTime((HANDLE)LongToHandle(pfhDst->iDosfh), NULL, NULL, &WriteTime)
                    || !FileTimeToDosDateTime(&WriteTime, &dateDst, &timeDst)) {
                if ((eerc = EercErrorHandler(hwndFrame, grcReadFileErr, fVital,
                        szFullPathDst, 0, 0)) != eercRetry) {
                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                }
            }

            if (dateDst != dateSrc || timeDst != 0) {
                fRet = fTrue;
                fRemovePartialFile = fFalse;
                goto LCopyError;
            }

            while ((lfaDst =  LfaSeekFile(pfhDst, 0, sfmEnd)) == (LFA)(-1)) {
                if ((eerc = EercErrorHandler(hwndFrame, grcReadFileErr, fVital,
                        szFullPathDst, 0, 0)) != eercRetry) {
                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                }
            }
        }

        if (fDecomp) {
            INT rc;
            while ((rc = LZInit( pfhSrc->iDosfh) ) < 0) {
                GRC grc;

                switch (rc) {

                case LZERROR_UNKNOWNALG:
                    grc = grcDecompUnknownAlgErr;
                    break;

                case LZERROR_GLOBLOCK:
                case LZERROR_READ:
                case LZERROR_BADINHANDLE:
                    grc = grcReadFileErr;
                    break;

                case LZERROR_GLOBALLOC:
                    grc = grcOutOfMemory;
                    break;

                default:
                    grc = grcDecompGenericErr;
                    break;

                }

                if ((eerc = EercErrorHandler(hwndFrame, grc, fVital, szFullPathSrc,
                        0, 0)) != eercRetry) {
                    fRet = (eerc == eercIgnore);
                    hSource = NULL;
                    goto LCopyError;
                }
            }
            hSource = (HANDLE)LongToHandle(rc);
        }
        else {
            hSource = (HANDLE)LongToHandle(pfhSrc->iDosfh);
        }

        if (fDecomp) {

            BOOL isDiamondFile;

            iTickMax = cProgTicks;
            iTickCur = 0;

            //
            // Determine whether the file is a diamond cabinet/compressed file.
            // If it is, we'll call a separate diamond decompressor.  If it isn't,
            // we'll call the lz routine, which will decompress an lz file or copy
            // a non-lz (and non-diamond) file.
            //
            isDiamondFile = IsDiamondFile(szFullPathSrc);

            do {

                if(isDiamondFile) {
                    lRet = DecompDiamondFile(
                                szFullPathSrc,
                                (HANDLE)LongToHandle(pfhDst->iDosfh),
                                fSilentSystem ? NULL: WFromW,
                                cProgTicks
                                );
                } else {
                    lRet = LcbDecompFile(
                                hSource,
                                (HANDLE)LongToHandle(pfhDst->iDosfh),
                                fSilentSystem ? NULL: WFromW,
                                cProgTicks
                                );
                }

                if(lRet < 0) {

                    GRC grc;
                    SZ  sz = szFullPathSrc;

                    switch (lRet) {

                    case rcReadError:
                    case rcReadSeekError:
                        grc = grcReadFileErr;
                        break;

                    case rcWriteError:
                    case rcWriteSeekError:
                        grc = grcWriteFileErr;
                        sz = szFullPathDst;
                        break;

                    case rcOutOfMemory:
                        grc = grcOutOfMemory;
                        break;
                    case rcDiskFull:
                        grc = grcDiskFull;
                        fVital = TRUE;
                        break;

                    case rcUserQuit:
                        fRet = fFalse;
                        goto LCopyError;
                        break;

                    default:
                        grc = grcDecompGenericErr;
                        break;
                    }

                    if ((eerc = EercErrorHandler(hwndFrame, grc, fVital, sz)) !=
                            eercRetry)
                    {
                        fRet = (eerc == eercIgnore);
                        goto LCopyError;
                    }

                    //
                    // Before retrying we need to rewind the destination pointer to
                    // the place where we began the write
                    //

                    while (LfaSeekFile(pfhDst, lfaDst, sfmSet) == (LFA)(-1)) {
                        if ((eerc = EercErrorHandler(hwndFrame, grcReadFileErr, fVital,
                                szFullPathDst, 0, 0)) != eercRetry) {
                            fRet = (eerc == eercIgnore);
                            goto LCopyError;
                        }
                    }
                }
            } while(lRet < 0);

            Assert(iTickCur <= cProgTicks);
            cProgTicks -= iTickCur;
        }
        else {
            iTickMax = cProgTicks;
            iTickCur = 0;
            while ((lRet = LcbCopyFile(
                               hSource,
                               (HANDLE)LongToHandle(pfhDst->iDosfh),
                               fSilentSystem ? NULL: WFromW,
                               cProgTicks
                               )) < 0) {

                GRC grc;
                SZ  sz = szFullPathSrc;

                switch (lRet) {

                case rcReadError:
                case rcReadSeekError:
                    grc = grcReadFileErr;
                    break;

                case rcWriteError:
                case rcWriteSeekError:
                    grc = grcWriteFileErr;
                    sz = szFullPathDst;
                    break;

                case rcOutOfMemory:
                    grc = grcOutOfMemory;
                    break;
                case rcDiskFull:
                    grc = grcDiskFull;
                    fVital = TRUE;
                    break;

                case rcUserQuit:
                    fRet = fFalse;
                    goto LCopyError;
                    break;

                default:
                    grc = grcDecompGenericErr;
                    break;
                }

                if ((eerc = EercErrorHandler(hwndFrame, grc, fVital, sz)) !=
                        eercRetry)
                {
                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                }

                //
                // Before retrying we need to rewind the destination pointer to
                // the place where we began the write
                //

                while (LfaSeekFile(pfhDst, lfaDst, sfmSet) == (LFA)(-1)) {
                    if ((eerc = EercErrorHandler(hwndFrame, grcReadFileErr, fVital,
                            szFullPathDst, 0, 0)) != eercRetry) {
                        fRet = (eerc == eercIgnore);
                        goto LCopyError;
                    }
                }
            }


            Assert(iTickCur <= cProgTicks);
            cProgTicks -= iTickCur;

        }


        if (oef & oefTimeStamp)
            while (!SetFileTime((HANDLE)LongToHandle(pfhDst->iDosfh), &CreateTime, &AccessTime,
                    &WriteTime))
                if ((eerc = EercErrorHandler(hwndFrame, grcWriteFileErr, fVital,
                        szFullPathDst, 0, 0)) != eercRetry)
                    {
                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                    }

        if (fDecomp) {
            LZClose ( HandleToUlong(hSource) );
            FreePfh ( pfhSrc );
            hSource = NULL;
            pfhSrc  = NULL;

        }
        else {
            while (!FCloseFile(pfhSrc)) {
                if ((eerc = EercErrorHandler(hwndFrame, grcCloseFileErr, fVital,
                        szFullPathSrc, 0, 0)) != eercRetry)
                {
                    fRet = (eerc == eercIgnore);
                    goto LCopyError;
                }
            }
            pfhSrc = NULL;
        }

        //
        // If we get here, the file was copied successfully.
        // Close the file before we get the checksum
        //

        while (!FCloseFile(pfhDst)) {
            if ((eerc = EercErrorHandler(hwndFrame, grcCloseFileErr, fVital,
                    szFullPathDst, 0, 0)) != eercRetry)
            {
                fRet = (eerc == eercIgnore);
                goto LCopyError;
            }
        }
        pfhDst = NULL;

        ValidateAndChecksumFile( szFullPathDst,
                                 &IsNtImage,
                                 &Checksum,
                                 &IsValid );

        if(!IsValid) {
            if ((eerc = EercErrorHandler(hwndFrame, grcVerifyFileErr, fVital,
                    szFullPathDst, 0, 0)) != eercRetry)
            {
                fRet = (eerc == eercIgnore);
                goto LCopyError;
            }
        }

    } while(!IsValid);

    fRemovePartialFile = fFalse;

    //
    // At this point, we can delete the backup file we made (if we made one)
    //
    if(szActiveFileTmpName) {
        if(!FRemoveFile(szActiveFileTmpName)) {
            //
            // It must be locked, so set it to be deleted on reboot
            //
            AddFileToDeleteList(szActiveFileTmpName);
        }
        free(szActiveFileTmpName);
        szActiveFileTmpName = NULL;
    }

    if (oef & oefReadOnly)
        while (!FSetFileReadOnlyStatus(szFullPathDst, fOn))
            {
            if ((eerc = EercErrorHandler(hwndFrame, grcWriteFileErr, fVital,
                    szFullPathDst, 0, 0)) != eercRetry)
                {
                fRet = (eerc == eercIgnore);
                goto LCopyError;
                }
            }

    fRet = fTrue;


LCopyError:

    //
    // Log the file.
    //

    if(psdle && !(oef & oefNoLog) && !fCsdInstall) {
        LogOneFile( szNonCompressedFullPathSrc,
                    szFullPathDst,
                    psdle->szLabel,
                    Checksum,
                    psdle->szTagFile,
                    fThirdPartyFile
                  );
    }

    if (pbBuffer != (PB)NULL) {
        SFree(pbBuffer);
    }

    if (fDecomp && hSource != (HANDLE)NULL) {
        LZClose (HandleToUlong(hSource));
        FreePfh (pfhSrc);
    }
    else if (pfhSrc != (PFH)NULL) {
        EvalAssert(FCloseFile(pfhSrc));
    }

    if (pfhDst != (PFH)NULL) {
        EvalAssert(FCloseFile(pfhDst));
    }

    if (fRemovePartialFile) {

        FRemoveFile(szFullPathDst);

        if(szActiveFileTmpName) {
            MoveFile(szActiveFileTmpName, szFullPathDst);
            free(szActiveFileTmpName);
        }
    }

    //
    // If we have any remaining ticks on the gauge for this file,
    // go ahead and do them.  This could happen if the file copy was
    // aborted part way through.
    //
    if (cProgTicks > 0 && !fSilentSystem) {
        ProDeltaPos(cProgTicks);
    }

DelSrc:

    //
    // Determine whether we are supposed to delete the source file.  This
    // is the case when it is coming from a local source as created by the
    // DOS Setup program, and is not marked oefNoDeleteSource.
    //

    if(!fNTUpgradeSetup && OnLocalSource && !(oef & oefNoDeleteSource))
    {
        if (NULL == SzFindSymbolValueInSymTab("!STF_NETDELETEOVERIDE"))
        {
            DeleteFile(szFullPathSrc);
        }
    }

    return(fRet);
}


/*
**  Purpose:
**      To find a pointer to the beginning of the file name (i.e. primary.ext)
**      at the end of a fully qualified pathname.
**  Arguments:
**      szFullPath: a non-Null, zero-terminated string containing a
**          pathname ending in a file name.
**  Returns:
**      an SZ which is a pointer to the beginning of the file name within the
**      argument SZ.
**
**************************************************************************/
SZ APIENTRY SzFindFileFromPath(szFullPath)
SZ szFullPath;
{
    SZ sz;
    SZ szSave = szFullPath;

    ChkArg(szFullPath != (SZ)NULL && *szFullPath != '\0'
                && *SzLastChar(szFullPath) != '\\', 1, (SZ)NULL);

    for (sz = szFullPath; *sz != '\0'; sz = SzNextChar(sz))
        if (*sz == '\\')
            szSave = sz;

    Assert(szSave != NULL);
    if (*szSave == '\\')
        szSave = SzNextChar(szSave);
    Assert(szSave != NULL && *szSave != '\0');

    return(szSave);
}


/*
**  Purpose:
**      To find the beginning the beginning of the extension part of the file
**      name within a string containing a file name (without the preceeding
**      path name).
**  Arguments:
**      szFile: a zero terminated character string containing a valid file
**          name (without the preceeding path name).
**  Returns:
**      an SZ that points to the '.' that begins the extension or '\0' if the
**          file has no extension.
**
**************************************************************************/
SZ APIENTRY SzFindExt(szFile)
SZ szFile;
{
    ChkArg(szFile != (SZ)NULL, 1, (SZ)NULL);

    for ( ; *szFile != '\0' && *szFile != '.'; szFile = SzNextChar(szFile))
        ;

    return(szFile);
}


/*
**  Purpose:
**      Build full path (check for ROOT and RENAME options)
**  Arguments:
**      szPath: non-NULL buffer to fill with full path.
**      szDst:  non-NULL string for szDstDir supplied on script line.
**      psfd:   non-NULL pointer to the Section-File Description structure(SFD).
**  Assumes:
**      szPath large enough for result.
**  Returns:
**      fTrue if successfully able to create the path, fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY
FBuildFullDstPath(
    SZ   szPath,
    SZ   szDst,
    PSFD psfd,
    BOOL fCompressedName
    )
{
    SZ   szFile;
    SZ   szFileDollar = NULL;
    POER poer = &(psfd->oer);
    BOOL bStatus;

    ChkArg(szPath != (SZ)NULL, 1, fFalse);
    ChkArg(szDst  != (SZ)NULL && FValidDir(szDst), 2, fFalse);
    ChkArg(psfd != (PSFD)NULL, 3, fFalse);

    if (poer->szDest != NULL) {
        szDst = poer->szDest;
    }

    if (poer->szAppend != NULL) {
        szFile = poer->szAppend;
    }
    else if (poer->szRename != NULL) {
        szFile = poer->szRename;
    }
    else {
        if (poer->oef & oefRoot) {
            szFile = SzFindFileFromPath(psfd->szFile);
        }
        else {
            szFile = psfd->szFile;
        }

        if (!(poer->oef & oefDecompress) && fCompressedName) {
            while ((szFileDollar = SzGetSrcDollar(szFile,'_')) == (SZ)NULL) {
                if (!FHandleOOM(hwndFrame)) {
                    return(fFalse);
                }
            }
            szFile = szFileDollar;
        }
    }
    bStatus = FMakePathFromDirAndSubPath(szDst, szFile, szPath, cchpFullPathBuf);
    if ( szFileDollar ) {
        SFree( szFileDollar);
    }
    return(bStatus);
}

/*
**  Purpose:
**      Build full source path
**  Arguments:
**      szPath:    non-NULL buffer to store result in.
**      szDst:     non-NULL valid subpath for dest.
**      szFile:    non-NULL file name.
**      szNetPath: string pointer for netpath to use; NULL to ignore.
**  Assumes:
**      szPath large enough for result.
**  Returns:
**      fTrue if the path is built correctly, fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY FBuildFullSrcPath(szPath, szDst, szFile, szNetPath)
SZ szPath;
SZ szDst;
SZ szFile;
SZ szNetPath;
{
    CHP szPathTmp[cchpFullPathBuf];

    ChkArg(szPath != (SZ)NULL, 1, fFalse);
    ChkArg(szDst  != (SZ)NULL, 2, fFalse);
    ChkArg(szFile != (SZ)NULL, 3, fFalse);

    if (szNetPath == NULL)
        return(FMakePathFromDirAndSubPath(szDst, szFile, szPath,
            cchpFullPathBuf));
    else if (FMakePathFromDirAndSubPath(szDst, szNetPath, szPathTmp,
                cchpFullPathBuf) &&
            FMakePathFromDirAndSubPath(szPathTmp, szFile, szPath,
                cchpFullPathBuf))
        return(fTrue);
    else
        return(fFalse);
}


/*
**  Purpose:
**      Build full BackupPath
**  Arguments:
**      szPath: non-NULL buffer to store result in.
**      szDst:  non-NULL valid subpath for dest.
**      psfd:   non-NULL SFD pointer.
**  Assumes:
**      szPath large enough for result.
**  Returns:
**      fTrue if successful; fFalse otherwise.
**
**************************************************************************/
BOOL APIENTRY FBuildFullBakPath(szPath, szDst, psfd)
SZ   szPath;
SZ   szDst;
PSFD psfd;
{
    SZ sz;

    ChkArg(szPath != (SZ)NULL, 1, fFalse);
    ChkArg(szDst != (SZ)NULL && *szDst != '\0', 2, fFalse);
    ChkArg(psfd != (PSFD)NULL && (psfd->oer).szBackup != NULL, 3, fFalse);

    EvalAssert(szPath == szDst || strcpy(szPath, szDst) == szPath);
    sz = SzFindFileFromPath(szPath);
    Assert(sz != NULL && *sz != '\0');

    if (*((psfd->oer).szBackup) == '*')
        {
        sz = SzFindExt(szPath);
        *sz++ = '.';
        *sz++ = 'B';   /* REVIEW INTL */
        *sz++ = 'A';
        *sz++ = 'K';
        *sz++ = '\0';
        return(fTrue);
        }

    *sz = '\0';
    return(FMakePathFromDirAndSubPath(szPath, (psfd->oer).szBackup, szPath,
                cchpFullPathBuf));
}


/*
**  Purpose:
**      Verifies given file actually exists.
**  Arguments:
**  Returns:
**
**************************************************************************/
BOOL APIENTRY FFileFound(szPath)
SZ szPath;
{
    WIN32_FIND_DATA ffd;
    HANDLE          SearchHandle;

    ChkArg(szPath != (SZ)NULL &&
            *szPath != '\0', 1, fFalse);

    if ( (SearchHandle = FindFirstFile( szPath, &ffd )) == INVALID_HANDLE_VALUE ) {
        return( fFalse );
    }
    else {
        FindClose( SearchHandle );
        return( fTrue );
    }
}


/*
**  Purpose:
**  Arguments:
**  Returns:
**
**************************************************************************/
BOOL APIENTRY FYield(VOID)
{
    MSG  msg;
    BOOL fRet = fTrue;

    while (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
        {
        if (hwndProgressGizmo != NULL
                && IsDialogMessage(hwndProgressGizmo, &msg))
            continue;

        if (msg.message == WM_QUIT)
            fRet = fFalse;

//        if (CheckSpecialKeys(&msg))
//            continue;

        TranslateMessage(&msg);
        DispatchMessage(&msg);
        }

    return(fRet);
}


/*
**  Purpose:
**      To check and see if the directory specified in szFullPathDst exists.
**      If not, it will create the directory (including any intermediate
**      directories).  For example if szFullPathDst = "c:\\a\\b\\File" and
**      none of these directories exist (i.e. a or b) they will all be
**      created so that the complete path exists (File is not created).
**  Arguments:
**      szFullPathDst: The complete pathname (including drive) of the directory
**          in question.
**      fCritical:     if fTrue success of this operation is required for
**          success of the setup program as a whole. Setup will be terminated
**          if fCritical is fTrue and this function fails.
**      szMsg:         The complete pathname (including drive) of the directory
**          to display in an error.  If NULL use szFullPathDst.
**  Returns:
**      a YNRC error code (see _filecm.h) indicating the outcome of this
**      function.
**
**************************************************************************/
YNRC APIENTRY YnrcEnsurePathExists(szFullPathDst, fCritical, szMsg)
SZ   szFullPathDst;
BOOL fCritical;
SZ   szMsg;
{
    CHP     szTmp[cchpFullPathBuf];
    SZ      sz;
    DWORD   Attr;
    EERC    eerc;
    YNRC    ynrc = ynrcYes;

    ChkArg(FValidPath(szFullPathDst),1,ynrcNo);

    if (szMsg == (SZ)NULL) {
        szMsg = szFullPathDst;
    }

    EvalAssert(strcpy((SZ)szTmp, szFullPathDst) ==
            (SZ)szTmp);

    EvalAssert((sz = SzFindFileFromPath(szTmp)) != (SZ)NULL);
    EvalAssert((sz = SzPrevChar(szTmp, sz)) != (SZ)NULL);
    Assert(*sz == '\\');
    *sz = '\0';

    while ( !( ((Attr = GetFileAttributes(szTmp)) != 0xFFFFFFFF  && (Attr & FILE_ATTRIBUTE_DIRECTORY ))
               || CreateDirectory( szTmp, NULL )
             )
          ) {
        if ((eerc = EercErrorHandler(hwndFrame, grcCreateDirErr, fCritical,
                szMsg, 0, 0)) != eercRetry) {
            ynrc = (eerc == eercIgnore) ? ynrcErr1 : ynrcNo;
            break;
        }
    }
    return( ynrc );
}


int
DetermineDriveType(
    IN CHAR DriveLetter
    )

/*++

Routine Description:

    Determine whether a drive is removable media -- which can be
    a floppy or a CD-ROM. Removeable hard drives are NOT considered
    removeable by this routine.

Arguments:

    DriveLetter - supplies drive letter of drive to check. If this
        is not a valid alpha char, FALSE is returned.

Return Value:

    -2 - Drive is a CD-ROM
    -1 - Drive is some other removeable type (such as floppy)
     0 - Drive is not removeable (or we couldn't tell)

--*/

{
    CHAR Name[4];
    UINT DriveType;
    CHAR DevicePath[MAX_PATH];

    Name[0] = DriveLetter;
    Name[1] = ':';
    Name[2] = '\\';
    Name[3] = 0;

    DriveType = GetDriveType(Name);

    if(DriveType == DRIVE_REMOVABLE) {

        Name[2] = 0;

        if(QueryDosDevice(Name,DevicePath,MAX_PATH)) {
            CharUpper(DevicePath);
            if(strstr(DevicePath,"HARDDISK")) {
                DriveType = DRIVE_FIXED;
            }
        }
    }

    if(DriveType == DRIVE_REMOVABLE) {
        return(-1);
    }

    if(DriveType == DRIVE_CDROM) {
        return(-2);
    }

    return(0);
}


/*
**  Purpose:
**  Arguments:
**      hInstance:  non-NULL instance handle for getting strings from
**          resources for SwapDisk message Box.
**      szLabel:  non-Null zero-terminated ANSI string to display as the
**          label of the diskette to prompt for.
**      szSrcDir: non-Null zero-terminated ANSI string to display as the
**          drive/directory the user is to insert the diskette into.
**  Returns:
**
**************************************************************************/
BOOL APIENTRY FPromptForDisk(hInstance, szLabel, szSrcDir)
HANDLE hInstance;
SZ     szLabel;
SZ     szSrcDir;
{
    CHAR szTmpText[cchpBufTmpLongMax];
    CHAR rgchBuf[3*cchpFullPathBuf];
    BOOL fRet;
    HWND hwndSav;

    ChkArg(hInstance,1,fFalse);
    ChkArg(szLabel && *szLabel &&
            strlen(szLabel) <= cchpFullPathMax, 2, fFalse);
    ChkArg(szSrcDir &&
            *szSrcDir &&
            strlen(szSrcDir) <= cchpFullPathMax, 3, fFalse);

    EvalAssert(LoadString(hInstance, IDS_INS_DISK, rgchBuf,3*cchpFullPathBuf));
    EvalAssert(SzStrCat(rgchBuf, szLabel) == rgchBuf);
    EvalAssert(LoadString(hInstance, IDS_INTO, szTmpText,
            cchpBufTmpLongMax));
    EvalAssert(SzStrCat(rgchBuf, szTmpText) == rgchBuf);
    EvalAssert(SzStrCat(rgchBuf, szSrcDir) == rgchBuf);

    EvalAssert(LoadString(hInstance, IDS_ERROR, szTmpText,
            cchpBufTmpLongMax));

    hwndSav = GetFocus();
    fRet = (MessageBox(hwndFrame,rgchBuf,szTmpText,MB_OKCANCEL|MB_TASKMODAL) == IDOK);
    SetFocus(hwndSav);
    SendMessage(hwndFrame, WM_NCACTIVATE, 1, 0L);

    return(fRet);
}


/*
**  Purpose:
**      To rename an active file as an del????.tmp file which will be deleted if
**      the new file is copied successfully.
**  Arguments:
**      szFullPath: Full pathname of active file
**  Returns:
**      The name of the renamed file, or NULL if unsuccessful.
**
**************************************************************************/
SZ APIENTRY
FRenameActiveFile(
    SZ szFullPath
    )
{
    SZ      szTmpName;
    CHP     szDir[MAX_PATH];
    SZ      sz;

    ChkArg ( szFullPath != NULL, 1, NULL);

    //
    // Try to find a temp filename we can use in the destination directory
    //

    lstrcpy( szDir, szFullPath );
    if( !(sz = strrchr( szDir, '\\')) ) {
        return NULL;
    }
    *sz = '\0';

    if(!(szTmpName = malloc((lstrlen(szDir) + 14) * sizeof(CHP)))) {
        return NULL;
    }

    if(!GetTempFileName( szDir, "del", 0, szTmpName )) {
        goto FileRenameFailed;
    }

    //
    // GetTempFileName creates the temp file.  It needs to be deleted
    //

    if (FFileFound(szTmpName) && !FRemoveFile(szTmpName)) {
        goto FileRenameFailed;
    }

    //
    // Rename the original file to this filename
    //

    if( MoveFile( szFullPath, szTmpName ) ) {
        return szTmpName;
    }

FileRenameFailed:

    free(szTmpName);
    return NULL;
}


BOOL
FGetFileSecurity(
    PCHAR File,
    PSECURITY_DESCRIPTOR *SdBuf,
    CB *SdLen
    )
{
    #define CBSDBUF 1024
    SECURITY_INFORMATION Si;
    PSECURITY_DESCRIPTOR Sd, SdNew;
    DWORD cbSd = CBSDBUF;
    DWORD cbSdReq;
    BOOL  FirstTime = fTrue;
    DWORD dw1, dw2;
    EERC    eerc;

    static CHAR  Root[MAX_PATH] = "\0";
    static BOOL  IsNtfs = FALSE;
    CHAR  VolumeFSName[MAX_PATH];

    //
    // Initialize
    //
    *SdBuf = NULL;

    //
    // Check if the volume information is in the cache, if not so get the
    // volume information and put it in the cache
    //

    if( Root[0] == '\0' ) {
        if( !ISUNC( File ) ) {
            strncpy( Root, File, 3 );
            Root[3] = '\0';
        } else {
            PCHAR   p;
            ULONG   n;

            p = File + 2;
            if( ( ( p = strchr( p, '\\' ) ) == NULL ) ||
                ( ( p = strchr( p + 1, '\\' ) ) == NULL ) ) {
                return( FALSE );
            }
            n = (ULONG)(p - File + 1);
            strncpy( Root, File, n );
            Root[ n ] = '\0';
        }
        while(!GetVolumeInformation( Root, NULL, 0, NULL, &dw1, &dw2, VolumeFSName, MAX_PATH )) {
            if ((eerc = EercErrorHandler(hwndFrame, grcGetVolInfo, FALSE, Root, File, 0)) != eercRetry) {
                return(eerc == eercIgnore);
            }
        }
        IsNtfs = !lstrcmpi( VolumeFSName, "NTFS" );
    }

    if(!IsNtfs) {
        return(TRUE);
    }

    //
    // Allocate memory for the security descriptor
    //
    while ((Sd = SAlloc(cbSd)) == NULL ) {
        if (!FHandleOOM(hwndFrame)) {
            return(fFalse);
        }
    }

    //
    // Get the security information from the source file
    //

    Si = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;
    while(!GetFileSecurity(File,Si,Sd,cbSd,&cbSdReq)) {
        if( FirstTime && (cbSdReq > cbSd) ) {
            while(!(SdNew = SRealloc(Sd,cbSdReq))) {
                if (!FHandleOOM(hwndFrame)) {
                    SFree(Sd);
                    return(fFalse);
                }
            }
            cbSd      = cbSdReq;
            Sd        = SdNew;
        }
        else {
            if ((eerc = EercErrorHandler(hwndFrame, grcGetFileSecurity, FALSE, File, 0, 0)) != eercRetry) {
                SFree(Sd);
                return(eerc == eercIgnore);
            }
        }
        FirstTime = fFalse;
    }

    *SdBuf = Sd;
    *SdLen = cbSd;
    return(TRUE);
}

BOOL
FSetFileSecurity(
    PCHAR File,
    PSECURITY_DESCRIPTOR SdBuf
    )
{
    EERC    eerc;
    SECURITY_INFORMATION Si;

    //
    // Set the Security on the dest file
    //
    Si = OWNER_SECURITY_INFORMATION | GROUP_SECURITY_INFORMATION | DACL_SECURITY_INFORMATION;
    while(!SetFileSecurity(File, Si, SdBuf)) {
#if 0
        //
        //  BUGBUG - This is to find an error in DaveC's machine
        //
        CHAR    DbgBuffer[256];
        ULONG   Error;

        Error = GetLastError();
        sprintf( DbgBuffer, "SetFileSecurity() failed. \nFile = %s. \nError = %d \n\nPlease contact JaimeS at x65903", File, Error );
        MessageBox(NULL, DbgBuffer, "Debug Message",
                                MB_OK | MB_ICONHAND);
#endif

        if ((eerc = EercErrorHandler(hwndFrame, grcSetFileSecurity, FALSE, File, 0, 0)) != eercRetry) {
            return(eerc == eercIgnore);
        }
    }
    return(TRUE);
}

BOOL
DoesFileReplaceThirdPartyFile(
    SZ  szFullPathDst
    )

{
    CHAR    SetupLogFilePath[ MAX_PATH ];
    PSTR    SectionName;
    CHAR    ReturnBuffer[512];
    PSTR    DefaultString = "";
    PSTR    SectionsToSearch[] = {
                                 "Files.WinNt",
                                 "Files.SystemPartition"
                                 };
    ULONG   Count;
    BOOL    ReplaceThirdParty;

    *SetupLogFilePath = '\0';
    GetWindowsDirectory( SetupLogFilePath, sizeof( SetupLogFilePath ) );
    strcat( SetupLogFilePath, SETUP_REPAIR_DIRECTORY );
    strcat( SetupLogFilePath, SETUP_LOG_FILE );

    for( Count = 0;
         Count < sizeof( SectionsToSearch ) / sizeof( PSTR );
         Count++ ) {

        SectionName = SectionsToSearch[Count];
        *ReturnBuffer = '\0';
        GetPrivateProfileString( SectionName,
                                 szFullPathDst,
                                 DefaultString,
                                 ReturnBuffer,
                                 sizeof( ReturnBuffer ),
                                 SetupLogFilePath );

        if( *ReturnBuffer != '\0' ) {
            break;
        }
    }

    ReplaceThirdParty = FALSE;
    if( *ReturnBuffer != 0  ) {
        PSTR    SourceFileName;
        PSTR    ChkSumString;
        PSTR    DirectoryOnSourceDevice;
        PSTR    DiskDescription;
        PSTR    DiskTag;
        PSTR    Delimiters = "\" ,";

        SourceFileName = strtok( ReturnBuffer, Delimiters );
        SourceFileName = strtok( NULL, Delimiters );
        ChkSumString = strtok( NULL, Delimiters );
        DirectoryOnSourceDevice = strtok( NULL, Delimiters );
        DiskDescription = strtok( NULL, Delimiters );
        DiskTag = strtok( NULL, Delimiters );

        if( ( DiskDescription != NULL ) || ( DiskTag != NULL ) ) {
            ReplaceThirdParty = TRUE;
        }
    }
    return( ReplaceThirdParty );
}