windows-xp/Source/XPSP1/NT/base/ntsetup/win95upg/w95upg/migapp/helpers.c

/*++

Copyright (c) 1997 Microsoft Corporation

Module Name:

    helpers.c

Abstract:

    Implements a set of functions that are called for every
    file or directory (before and after the AppDb processing).

Author:

    Calin Negreanu (calinn) 21-Nov-1997

Revision History:

    ovidiut     14-Feb-2000 Added support for fusion
    ovidiut     10-May-1999 Added GatherIniFiles (support for INI actions)
    jimschm     07-Jan-1999 CPLs are now known-good migration
    jimschm     23-Sep-1998 Cleanup for new fileops

--*/

#include "pch.h"
#include "migdbp.h"
#include "migappp.h"

/*++

Macro Expansion List Description:

  HELPER_FUNCTIONS contains a list of functions called for each file and directory
  during file scanning.

Line Syntax:

   DEFMAC(HelperName, HelperId)

Arguments:

   HelperName - this is the helper function. You must implement a function with this
                name and required parameters.

   HelperId   - this is the helper id. If your function handles the file it should
                update that in Params structure.

   CanHandleVirtualFiles - this is for enumerating some files that might not be on the
                system but we want them to be processed as if they were. A good example
                is backup.exe which must be replaced by ntbackup.exe. If the file is not
                on the system, all registry settings pointing to it will not be changed.

Variables Generated From List:

   g_HelperFunctionList - defined in helpers.c

--*/

#define HELPER_FUNCTIONS        \
        DEFMAC(IsFusionDir,             IS_FUSION_DIR,      FALSE)   \
        DEFMAC(MigDbTestFile,           MIGDB_TEST_FILE,    TRUE )   \
        DEFMAC(CheckOsFiles,            CHECK_OS_FILES,     FALSE)   \
        DEFMAC(pStoreCPLs,              STORE_CPL,          FALSE)   \
        DEFMAC(pCheckCpl,               CHECK_CPL,          FALSE)   \
        DEFMAC(pSetupTableFileHelper,   SETUP_TABLE_FILE,   FALSE)   \
        DEFMAC(ProcessHelpFile,         TEST_HELP_FILES,    FALSE)   \
        DEFMAC(SaveExeFiles,            SAVE_EXE_FILES,     FALSE)   \
        DEFMAC(SaveLinkFiles,           SAVE_LNK_FILES,     FALSE)   \
        DEFMAC(pGatherDunFiles,         GATHER_DUN_FILES,   FALSE)   \
        DEFMAC(pMigrationDllNotify,     MIGRATION_DLL,      FALSE)   \
        DEFMAC(GatherBriefcases,        GATHER_BRIEFCASES,  FALSE)   \
        DEFMAC(GatherIniFiles,          GATHER_INI_FILES,   FALSE)   \
        DEFMAC(TestNtFileName,          TEST_NT_FILE_NAME,  FALSE)   \
        DEFMAC(BackUpIsuFiles,          BACKUP_ISU_FILES,   FALSE)   \
        DEFMAC(EditHtmlFiles,           EDIT_HTML_FILES,    FALSE)   \

#if 0

        //
        // the appcompat team doesn't support "APPMIG.INF" any longer
        // and they requested us to no longer depend on it
        //
        DEFMAC(AppCompatTestFile,       APPCOMPAT_TEST_FILE,FALSE)   \

#endif

#define DEFMAC(fn,id,can)   id,
typedef enum {
    START_OF_LIST,
    HELPER_FUNCTIONS
    END_OF_LIST
} HELPER_FUNCTIONS_ID;
#undef DEFMAC

//
// Declare a global array of function pointers
//
typedef BOOL (HELPER_PROTOTYPE) (PFILE_HELPER_PARAMS p);

typedef HELPER_PROTOTYPE *PHELPER_PROTOTYPE;

/*
   Declare the helper functions
*/
#define DEFMAC(fn,id,can) HELPER_PROTOTYPE fn;
HELPER_FUNCTIONS
#undef DEFMAC

/*
   This is the structure used for handling helper functions
*/
typedef struct {
    PCSTR HelperName;
    PHELPER_PROTOTYPE HelperFunction;
    BOOL CanHandleVirtualFiles;
} HELPER_STRUCT, *PHELPER_STRUCT;

/*
   Declare a global array of functions and name identifiers for helper functions
*/
#define DEFMAC(fn,id,can) {#id, fn, can},
static HELPER_STRUCT g_HelperFunctions[] = {
                              HELPER_FUNCTIONS
                              {NULL, NULL, FALSE}
                              };
#undef DEFMAC

extern BOOL g_IsFusionDir;

BOOL
ProcessFileHelpers (
    IN OUT  PFILE_HELPER_PARAMS Params
    )
/*++

Routine Description:

  Calls every helper function listed in the macro expansion list.
  If a helper function returns FALSE, this function returns FALSE.

Arguments:

  Params - Specifies the parameters for the current object

Return Value:

  TRUE if success, FALSE if failure.

--*/
{
    PHELPER_STRUCT currentHelper = g_HelperFunctions;
#ifdef DEBUG
    BOOL InterestingFile;
    TCHAR DbgBuf[32];

    //
    // Check if this file is in [FilesToTrack] inside debug.inf
    //

    GetPrivateProfileString ("FilesToTrack", Params->FullFileSpec, "", DbgBuf, ARRAYSIZE(DbgBuf), g_DebugInfPath);
    if (!(*DbgBuf) && Params->FindData) {
        GetPrivateProfileString ("FilesToTrack", Params->FindData->cFileName, "", DbgBuf, ARRAYSIZE(DbgBuf), g_DebugInfPath);
    }

    InterestingFile = (*DbgBuf != 0);

#endif

    while (currentHelper->HelperFunction) {

        if ((!Params->VirtualFile) ||
            (currentHelper->CanHandleVirtualFiles)
            ) {

#ifdef DEBUG

            if (InterestingFile) {
                DEBUGMSG ((
                    DBG_TRACK,
                    "Calling %s for %s",
                    currentHelper->HelperName,
                    Params->FullFileSpec
                    ));
            }
#endif

            if (!currentHelper->HelperFunction (Params)) {

#ifdef DEBUG

                if (InterestingFile) {
                    DEBUGMSG ((
                        DBG_TRACK,
                        "%s failed for %s",
                        currentHelper->HelperName,
                        Params->FullFileSpec
                        ));
                }
#endif

                return FALSE;
            }

#ifdef DEBUG

            if (InterestingFile) {
                DEBUGMSG ((
                    DBG_TRACK,
                    "%s returned, Handled = %u (0x%08X)",
                    currentHelper->HelperName,
                    Params->Handled
                    ));
            }
#endif

        }
        currentHelper++;
    }

    return TRUE;
}



BOOL
pGatherDunFiles (
    IN OUT PFILE_HELPER_PARAMS Params
    )
/*++

Routine Description:

  pGatherDunFiles adds a memdb entry for any file that has an extension
  of .DUN, and then sets the HandledBy type to GATHER_DUN_FILES.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{

    if (StringIMatch (Params->Extension, TEXT(".DUN"))) {
        MemDbSetValueEx (MEMDB_CATEGORY_DUN_FILES, Params->FullFileSpec, NULL, NULL, 0, NULL);
        Params->Handled = GATHER_DUN_FILES;
    }

    return TRUE;

}


BOOL
pSetupTableFileHelper (
    IN OUT  PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  pSetupTableFileHelper adds a memdb entry for any file that has an extension
  of .STF, and then sets the HandledBy type to SETUP_TABLE_FILE.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    if (StringIMatch (Params->Extension, TEXT(".STF"))) {
        MemDbSetValueEx (MEMDB_CATEGORY_STF, Params->FullFileSpec, NULL, NULL, 0, NULL);
        Params->Handled = SETUP_TABLE_FILE;
        MarkFileForBackup (Params->FullFileSpec);
    }

    return TRUE;
}


BOOL
pMigrationDllNotify (
    IN OUT  PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  pMigrationDllNotify calls the migration DLL code to update any DLL that
  wants to know where a particular file is on the system.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    if (!Params->VirtualFile) {
        MYASSERT (Params->FindData);

        if (!(Params->IsDirectory)) {
            if (!UpdateFileSearch (Params->FullFileSpec, Params->FindData->cFileName)) {
                DEBUGMSG ((DBG_WARNING, "UpdateFileSearch returned FALSE"));
                return FALSE;
            }
        }
    }

    return TRUE;
}


BOOL
pStoreCPLs (
    IN OUT  PFILE_HELPER_PARAMS Params
    )
{
    PCTSTR ModuleExt;

    ModuleExt = GetFileExtensionFromPath (Params->FullFileSpec);

    if ((ModuleExt) && (StringIMatch (ModuleExt, TEXT("CPL")))) {

        MemDbSetValueEx (
            MEMDB_CATEGORY_CPLS,
            Params->FullFileSpec,
            NULL,
            NULL,
            0,
            NULL
            );
    }

    return TRUE;
}

BOOL
pCheckCpl (
    IN OUT  PFILE_HELPER_PARAMS Params
    )
{
    DWORD Status;
    PCTSTR ModuleExt;

    if (Params->Handled == 0) {

        ModuleExt = GetFileExtensionFromPath (Params->FullFileSpec);

        if ((ModuleExt) && (StringIMatch (ModuleExt, TEXT("CPL")))) {

            if (!IsFileMarkedAsKnownGood (Params->FullFileSpec)) {

                //
                // Delete the file if it is displayable
                //

                if (IsDisplayableCPL (Params->FullFileSpec) &&
                    !TreatAsGood (Params->FullFileSpec)
                    ) {

                    DisableFile (Params->FullFileSpec);

                    Status = GetFileStatusOnNt (Params->FullFileSpec);

                    if (!(Status & FILESTATUS_REPLACED)) {
                        //
                        // Announce this CPL as bad because:
                        //
                        // - It is not known good
                        // - NT does not replace it
                        //

                        ReportControlPanelApplet (
                            Params->FullFileSpec,
                            NULL,
                            ACT_INCOMPATIBLE
                            );
                    }
                }
            }
        }
    }

    return TRUE;
}


BOOL
CheckOsFiles (
    IN OUT  PFILE_HELPER_PARAMS Params
    )
{
    TCHAR key[MEMDB_MAX];
    PCTSTR filePtr;
    DWORD fileStatus;
    PCTSTR newFileName;
    BOOL bIsWin9xOsPath;

    if (Params->Handled == 0) {
        filePtr = GetFileNameFromPath (Params->FullFileSpec);
        if (filePtr) {

            MemDbBuildKey (key, MEMDB_CATEGORY_NT_FILES, filePtr, NULL, NULL);
            if (MemDbGetValue (key, NULL)) {
                MemDbBuildKey (key, MEMDB_CATEGORY_NT_FILES_EXCEPT, filePtr, NULL, NULL);
                if (!MemDbGetValue (key, NULL)) {
                    //
                    // only do this for files in a MigrationDir
                    //
                    if (IsMigrationPathEx (Params->DirSpec, &bIsWin9xOsPath) && bIsWin9xOsPath) {
                        if (GlobalVersionCheck (Params->FullFileSpec, "COMPANYNAME", "*MICROSOFT*")) {
                            MYASSERT (Params->CurrentDirData);
                            if (!g_IsFusionDir || !IsNtCompatibleModule (Params->FullFileSpec)) {
                                //
                                // If this file is marked with any MOVE operations, remove those operations.
                                // we want this deletion to take precedence.
                                //
                                RemoveOperationsFromPath (
                                    Params->FullFileSpec,
                                    ALL_MOVE_OPERATIONS
                                    );
                                DeleteFileWithWarning (Params->FullFileSpec);
                                MarkFileAsOsFile (Params->FullFileSpec);
                                fileStatus = GetFileStatusOnNt (Params->FullFileSpec);
                                if ((fileStatus & FILESTATUS_REPLACED) != 0) {
                                    newFileName = GetPathStringOnNt (Params->FullFileSpec);
                                    if (StringIMatch (newFileName, Params->FullFileSpec)) {
                                        MarkFileForCreation (newFileName);
                                    } else {
                                        MarkFileForMoveByNt (Params->FullFileSpec, newFileName);
                                    }
                                    FreePathString (newFileName);
                                }
                                Params->Handled = CHECK_OS_FILES;
                            }
                        }
                    }
                }
            }
        }
    }
    return TRUE;
}


BOOL
GatherIniFiles (
    IN      PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  GatherIniFiles marks in memdb all INI files that have associated actions on NT.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    MEMDB_ENUM e;
    PTSTR NtPath;
    BOOL TempMove;
    BOOL DoIniAct;
    BOOL Success;
    DWORD Operations;

    if (Params->IsDirectory) {
        return TRUE;
    }
    if (Params->Handled) {
        return TRUE;
    }
    if (!StringIMatch(Params->Extension, TEXT(".INI"))) {
        return TRUE;
    }

    DoIniAct = FALSE;

    Params->Handled = GATHER_INI_FILES;

    TempMove = FALSE;
    //
    // Save selected INI filenames to memdb to perform actions on NT
    //
    if (MemDbGetValueEx (&e, MEMDB_CATEGORY_INIFILES_ACT_FIRST, NULL, NULL)) {
        do {
            //
            // if this dir name is matched, add this file to memdb and return
            //
            if (IsPatternMatch (e.szName, Params->FullFileSpec)) {
                //
                // move file in temp location
                //
                NtPath = GetPathStringOnNt (Params->FullFileSpec);
                if (!NtPath) {
                    //
                    // can't get path on NT!
                    //
                    DEBUGMSG ((
                        DBG_ERROR,
                        "GetPathStringOnNt (%s) returned NULL",
                        Params->FullFileSpec
                        ));
                    return FALSE;
                }

                Operations = GetOperationsOnPath (Params->FullFileSpec);
                if (Operations & OPERATION_FILE_MOVE_SHELL_FOLDER) {
                    DEBUGMSG ((
                        DBG_WARNING,
                        "Replacing operation OPERATION_FILE_MOVE_SHELL_FOLDER with OPERATION_TEMP_PATH for file %s",
                        Params->FullFileSpec
                        ));
                    RemoveOperationsFromPath (
                        Params->FullFileSpec,
                        OPERATION_FILE_MOVE_SHELL_FOLDER
                        );
                }

                Success = MarkFileForTemporaryMove (Params->FullFileSpec, NtPath, g_TempDir);
                FreePathString (NtPath);

                if (!Success) {
                    DEBUGMSG ((
                        DBG_ERROR,
                        "MarkFileForTemporaryMove (source=%s) returned FALSE",
                        Params->FullFileSpec
                        ));
                    return FALSE;
                }

                NtPath = GetPathStringOnNt (Params->DirSpec);
                Success = MarkDirectoryAsPreserved (NtPath);
                if (!Success) {
                    DEBUGMSG ((
                        DBG_ERROR,
                        "MarkDirectoryAsPreserved (%s) returned FALSE",
                        Params->DirSpec
                        ));
                }

                FreePathString (NtPath);

                TempMove = TRUE;

                MemDbSetValueEx (
                    MEMDB_CATEGORY_INIACT_FIRST,
                    Params->FullFileSpec,
                    NULL,
                    NULL,
                    0,
                    NULL
                    );
                DoIniAct = TRUE;
                break;
            }
        } while (MemDbEnumNextValue (&e));
    }

    if (MemDbGetValueEx (&e, MEMDB_CATEGORY_INIFILES_ACT_LAST, NULL, NULL)) {
        do {
            //
            // if this dir name is matched, add this file to memdb and return
            //
            if (IsPatternMatch (e.szName, Params->FullFileSpec)) {
                if (!TempMove) {
                    //
                    // move file in temp location
                    //
                    NtPath = GetPathStringOnNt (Params->FullFileSpec);
                    if (!NtPath) {
                        //
                        // can't get path on NT!
                        //
                        DEBUGMSG ((
                            DBG_ERROR,
                            "GetPathStringOnNt (%s) returned NULL",
                            Params->FullFileSpec
                            ));
                        return FALSE;
                    }

                    Operations = GetOperationsOnPath (Params->FullFileSpec);
                    if (Operations & OPERATION_FILE_MOVE_SHELL_FOLDER) {
                        DEBUGMSG ((
                            DBG_WARNING,
                            "Replacing operation OPERATION_FILE_MOVE_SHELL_FOLDER with OPERATION_TEMP_PATH for file %s",
                            Params->FullFileSpec
                            ));
                        RemoveOperationsFromPath (
                            Params->FullFileSpec,
                            OPERATION_FILE_MOVE_SHELL_FOLDER
                            );
                    }
                    Success = MarkFileForTemporaryMove (Params->FullFileSpec, NtPath, g_TempDir);

                    FreePathString (NtPath);

                    if (!Success) {
                        DEBUGMSG ((
                            DBG_ERROR,
                            "MarkFileForTemporaryMove (source=%s) returned FALSE",
                            Params->FullFileSpec
                            ));
                        return FALSE;
                    }

                    NtPath = GetPathStringOnNt (Params->DirSpec);
                    Success = MarkDirectoryAsPreserved (NtPath);
                    if (!Success) {
                        DEBUGMSG ((
                            DBG_ERROR,
                            "MarkDirectoryAsPreserved (%s) returned FALSE",
                            Params->DirSpec
                            ));
                    }

                    FreePathString (NtPath);

                    TempMove = TRUE;
                }

                MemDbSetValueEx (
                    MEMDB_CATEGORY_INIACT_LAST,
                    Params->FullFileSpec,
                    NULL,
                    NULL,
                    0,
                    NULL
                    );
                DoIniAct = TRUE;
                break;
            }
        } while (MemDbEnumNextValue (&e));
    }

    if (!DoIniAct) {
        //
        // ini files in %windir% are treated separately
        //
        if (!StringIMatch (Params->DirSpec, g_WinDirWack)) {
            //
            // Save all other INI filenames to memdb to convert them later on NT
            //
            MemDbSetValueEx (
                MEMDB_CATEGORY_INIFILES_CONVERT,
                Params->FullFileSpec,
                NULL,
                NULL,
                0,
                NULL
                );
            MarkFileForBackup (Params->FullFileSpec);
        }
    }

    return TRUE;
}


BOOL
GatherBriefcases (
    IN      PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  GatherBriefcases stores in memdb all Windows Briefcase Databases

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    if (!*Params->Extension && !Params->IsDirectory) {

        MYASSERT (Params->FindData);

        if (StringIMatch (
                GetFileNameFromPath (Params->FindData->cFileName),
                TEXT("Briefcase Database")
                )) {
            MemDbSetValueEx (
                MEMDB_CATEGORY_BRIEFCASES,
                Params->FullFileSpec,
                NULL,
                NULL,
                0,
                NULL
                );
            MarkFileForBackup (Params->FullFileSpec);
        }
    }

    return TRUE;
}


BOOL
pIsDirInPath (
    IN      PCTSTR FullDirSpec
    )
{
    PATH_ENUMA e;

    if (EnumFirstPathExA (&e, NULL, NULL, NULL, TRUE)) {
        do {
            if (StringIMatch (FullDirSpec, e.PtrCurrPath)) {
                return TRUE;
            }
        } while (EnumNextPath (&e));
    }

    return FALSE;
}


BOOL
pIsFusionDir (
    IN      PCTSTR FullDirSpec
    )
{
    HANDLE h;
    WIN32_FIND_DATA fd, fd2;
    TCHAR FileSpec[2 * MAX_TCHAR_PATH];
    TCHAR ExeName[2 * MAX_TCHAR_PATH];
    INT length;
    DWORD type;
    BOOL b = FALSE;

    MYASSERT (FullDirSpec);

    //
    // a fusion dir is never the root of a local drive or in windir or in path
    //
    if (SizeOfString (FullDirSpec) <= 4 ||
        StringIMatch (FullDirSpec, g_WinDir) ||
        StringIMatchCharCount (FullDirSpec, g_WinDirWack, g_WinDirWackChars) ||
        pIsDirInPath (FullDirSpec)
        ) {
        return FALSE;
    }
    length = wsprintf (FileSpec, TEXT("%s\\%s"), FullDirSpec, TEXT("*.local"));
    if (length <= MAX_PATH) {

        h = FindFirstFile (FileSpec, &fd);
        if (h != INVALID_HANDLE_VALUE) {

            do {
                length = wsprintf (ExeName, TEXT("%s%s"), FullDirSpec, fd.cFileName);
                //
                // cut the .local and check if this file exists
                //
                MYASSERT (ExeName[length - 6] == TEXT('.'));
                ExeName[length - 6] = 0;
                if (DoesFileExistEx (ExeName, &fd2) &&
                    !(fd2.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
                    ) {
                    type = GetExeType (ExeName);
                    b = (type == EXE_WIN32_APP) || (type == EXE_WIN16_APP);
                }

            } while (!b && FindNextFile (h, &fd));

            FindClose (h);
        }
    }

    return b;
}


BOOL
IsFusionDir (
    IN      PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  IsFusionDir tests if the current dir is a fusion directory;
  it will set the MIGAPP_DIRDATA_FUSION_DIR bit in *Params->CurrentDirData

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    //
    // this helper should be called before action functions (first ID is MIGDB_TEST_FILE)
    //
    MYASSERT (IS_FUSION_DIR < MIGDB_TEST_FILE);

    //
    // the caller must provide the storage space
    //
    MYASSERT (Params->CurrentDirData);
    if (!Params->CurrentDirData) {
        return FALSE;
    }

    if (!Params->IsDirectory) {

        if ((*Params->CurrentDirData & MIGAPP_DIRDATA_FUSION_DIR_DETERMINED) == 0) {
            if (pIsFusionDir (Params->DirSpec)) {
                *Params->CurrentDirData |= MIGAPP_DIRDATA_IS_FUSION_DIR;
            }
            *Params->CurrentDirData |= MIGAPP_DIRDATA_FUSION_DIR_DETERMINED;
        }

        g_IsFusionDir = (*Params->CurrentDirData & MIGAPP_DIRDATA_IS_FUSION_DIR) != 0;

    } else {
        g_IsFusionDir = FALSE;
    }

    return TRUE;
}


BOOL
TestNtFileName (
    IN      PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  TestNtFileName tests if the current file has the same name as one in [UseNtFiles];
  if it does, then renaming of this file on NT side is infibited, to ensure we don't
  change files that are not ours.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  Always TRUE.

--*/

{
    HASHITEM result;
    DWORD set;
    TCHAR key [MEMDB_MAX];
    MEMDB_ENUM e;
    PCTSTR name;

    if (!Params->IsDirectory && !Params->Handled) {
        name = GetFileNameFromPath (Params->FullFileSpec);
        if (g_UseNtFileHashTable) {
            result = HtFindStringAndData (g_UseNtFileHashTable, name, NULL);
            if (result) {
                DEBUGMSG ((
                    DBG_VERBOSE,
                    "Found unhandled [UseNtFiles] file %s; it's name will not be replaced",
                    name
                    ));
                //
                // remove this mapping from memdb
                //
                MemDbBuildKey (
                    key,
                    MEMDB_CATEGORY_USE_NT_FILES,
                    name,
                    NULL,
                    NULL
                    );
                MemDbDeleteTree (key);
                MYASSERT (!MemDbGetValueEx (&e, key, NULL, NULL));
                //
                // mark this file with data so that we know a file with this name
                // not handled by MigDb was found
                //
                set = 1;
                if (!HtSetStringData (g_UseNtFileHashTable, result, &set)) {
                    MYASSERT (FALSE);
                }
            }
        }
    }

    return TRUE;
}


BOOL
BackUpIsuFiles (
    IN      PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  BackUpIsuFiles collect all of the InstallShield files, so that they
  can be edited during GUI mode using code provided by InstallShield.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    MEMDB_ENUM e;
    PTSTR NtPath;
    BOOL TempMove;
    BOOL DoIniAct;
    BOOL Success;
    DWORD Operations;

    if (Params->IsDirectory) {
        return TRUE;
    }
    if (Params->Handled) {
        return TRUE;
    }
    if (!StringIMatch(Params->Extension, TEXT(".ISU"))) {
        return TRUE;
    }

    Params->Handled = BACKUP_ISU_FILES;

    MarkFileForBackup (Params->FullFileSpec);

    return TRUE;
}


BOOL
EditHtmlFiles (
    IN      PFILE_HELPER_PARAMS Params
    )

/*++

Routine Description:

  EditHtmlFiles examines all *.HTM? files and looks for the text FILE:. If it
  is found, then the file is added to the FileEdit group, so that references to
  local paths can be updated. The file is also marked for backup.

Arguments:

  Params - Specifies the file enumeration parameters

Return Value:

  TRUE if success, FALSE if failure.

--*/

{
    HANDLE file;
    HANDLE map;
    PBYTE image;
    PCSTR pos;
    PCSTR end;
    BOOL found = FALSE;
    TCHAR pathCopy[MAX_TCHAR_PATH];
    GROWBUFFER tokenArgBuf = GROWBUF_INIT;
    GROWBUFFER tokenSetBuf = GROWBUF_INIT;
    GROWBUFFER dataBuf = GROWBUF_INIT;
    PTOKENARG tokenArg;
    PTOKENSET tokenSet;
    TCHAR node[MEMDB_MAX];

    if (Params->IsDirectory) {
        return TRUE;
    }
    if (Params->Handled) {
        return TRUE;
    }

    if (!StringIMatch (Params->Extension, TEXT(".HTM")) &&
        !IsPatternMatch (Params->Extension, TEXT(".HTM?"))
        ) {
        return TRUE;
    }

    //
    // Exclude OS files
    //

    if (IsFileMarkedAsOsFile (Params->FullFileSpec)) {
        DEBUGMSG ((DBG_WARNING, "%s is an OS file; skipping file: ref update", Params->FullFileSpec));
        return TRUE;
    }

    //
    // Exclude Temporary Internet Files
    //

    StringCopy (pathCopy, Params->FullFileSpec);
    if (MappingSearchAndReplace (g_CacheShellFolders, pathCopy, sizeof (pathCopy))) {
        DEBUGMSG ((DBG_WARNING, "%s is in a Cache shell folder; skipping file: ref update", Params->FullFileSpec));
        return TRUE;
    }

    DEBUGMSG ((DBG_NAUSEA, "Checking %s for local references", Params->FullFileSpec));

    //
    // Already processed?
    //

    MemDbBuildKey (node, MEMDB_CATEGORY_FILEEDIT, Params->FullFileSpec, NULL, NULL);
    if (MemDbGetValue (node, NULL)) {
        DEBUGMSG ((DBG_NAUSEA, "%s is already processed; skipping", Params->FullFileSpec));
        return TRUE;
    }

    //
    // Scan file for text "FILE:"
    //

    image = (PBYTE) MapFileIntoMemory (Params->FullFileSpec, &file, &map);
    if (!image) {
        DEBUGMSG ((DBG_WARNING, "Can't map %s into memory; skipping", Params->FullFileSpec));
        return TRUE;
    }

    pos = (PCSTR) image;
    end = (PCSTR) ((PBYTE) pos + GetFileSize (file, NULL));

    if (end > pos + 1 && !(pos[0] == 0xFF && pos[1] == 0xFE)) {
        while (pos < end) {
            if (!isspace (*pos) && *pos != '\r' && *pos != '\n') {
                if (*pos < 32) {
                    DEBUGMSG ((DBG_VERBOSE, "File %s looks like it is binary; skipping", Params->FullFileSpec));
                    break;
                }

                if (*pos == 'F' || *pos == 'f') {
                    if (StringIPrefix (pos, TEXT("FILE:"))) {
                        found = TRUE;
                        DEBUGMSG ((DBG_VERBOSE, "File %s has FILE: in it; processing it as HTML", Params->FullFileSpec));
                        break;
                    }
                }
            }

            pos++;
        }
    }
    ELSE_DEBUGMSG ((DBG_WARNING, "File %s is not an ANSI file; skipping", Params->FullFileSpec));

    UnmapFile (image, map, file);

    //
    // Text found -- mark for edit & backup
    //

    if (found) {
        Params->Handled = EDIT_HTML_FILES;
        MarkFileForBackup (Params->FullFileSpec);

        //
        // Create an argument that has a detect pattern of * and UpdatePath
        // set to TRUE. We fill every member of TOKENARG here.
        //

        tokenArg = (PTOKENARG) GrowBuffer (&tokenArgBuf, sizeof (TOKENARG));
        tokenArg->DetectPattern = (PCSTR) (dataBuf.End + TOKEN_BASE_OFFSET);
        GrowBufCopyString (&dataBuf, TEXT("*"));

        tokenArg->SearchList = NULL;
        tokenArg->ReplaceWith = NULL;
        tokenArg->UpdatePath = TRUE;

        //
        // Create a token set of just one token argument. We fill every member
        // of TOKENSET here.
        //

        tokenSet = (PTOKENSET) GrowBuffer (
                                    &tokenSetBuf,
                                    sizeof (TOKENSET) +
                                        tokenArgBuf.End +
                                        dataBuf.End
                                    );

        tokenSet->ArgCount = 1;
        tokenSet->SelfRelative = TRUE;
        tokenSet->UrlMode = TRUE;
        tokenSet->CharsToIgnore = NULL;

        CopyMemory (tokenSet->Args, tokenArgBuf.Buf, tokenArgBuf.End);
        CopyMemory (
            (PBYTE) (tokenSet->Args) + tokenArgBuf.End,
            dataBuf.Buf,
            dataBuf.End
            );

        //
        // Save completed tokenSet to FileEdit category of memdb
        //

        MemDbSetBinaryValueEx (
            MEMDB_CATEGORY_FILEEDIT,
            Params->FullFileSpec,
            NULL,
            tokenSetBuf.Buf,
            tokenSetBuf.End,
            NULL
            );
    }
    ELSE_DEBUGMSG ((DBG_NAUSEA, "File %s does not have FILE: in it; skipping", Params->FullFileSpec));

    FreeGrowBuffer (&tokenArgBuf);
    FreeGrowBuffer (&tokenSetBuf);
    FreeGrowBuffer (&dataBuf);

    return TRUE;
}