windows-xp/Source/XPSP1/NT/base/fs/utils/replace/replace.cxx

/*++

Copyright (c) 1990-2000 Microsoft Corporation

Module Name:

        Replace

Abstract:

        Replace utility

Author:

        Ramon Juan San Andres (ramonsa) 01-May-1991

Revision History:

--*/

#include "ulib.hxx"
#include "arrayit.hxx"
#include "dir.hxx"
#include "filter.hxx"
#include "file.hxx"
#include "fsnode.hxx"
#include "stream.hxx"
#include "substrng.hxx"
#include "system.hxx"
#include "replace.hxx"

//
//      Pattern that matches all files in a directory
//
#define         MATCH_ALL_FILES         "*.*"


#define CTRL_C          (WCHAR)3



//
//      Size of buffers to hold path strings
//
#define         INITIAL_PATHSTRING_BUFFER_SIZE  MAX_PATH


VOID __cdecl
main (
        )

/*++

Routine Description:

        Main function of the Replace utility

Arguments:

    None.

Return Value:

    None.

Notes:

--*/

{
    //
    //      Initialize stuff
    //
    DEFINE_CLASS_DESCRIPTOR( REPLACE );

    //
    //      Now do the replacement
    //
    {
            REPLACE Replace;

            //
            //      Initialize the Replace object.
            //
            Replace.Initialize();

            //
            //      Do our thing
            //
            Replace.DoReplace();
    }
}




DEFINE_CONSTRUCTOR( REPLACE,    PROGRAM );



BOOLEAN
REPLACE::Initialize (
        )

/*++

Routine Description:

        Initializes the REPLACE object

Arguments:

    None.

Return Value:

        TRUE if initialized, FALSE otherwise

Notes:

--*/

{
        //
        //      Initialize program object
        //
        PROGRAM::Initialize( REPLACE_MESSAGE_USAGE );

        //
        //      Allocate global structures and initialize them
        //
        InitializeThings();

        //
        //      Parse the arguments
        //
        SetArguments();

        return TRUE;
}

REPLACE::~REPLACE (
        )

/*++

Routine Description:

        Destructs a REPLACE object

Arguments:

    None.

Return Value:

    None.

Notes:

--*/

{
    //
    //      Deallocate the global structures previously allocated
    //
    DeallocateThings();

    //
    //      Exit without error
    //
    DisplayMessageAndExit( 0, NULL, EXIT_NORMAL );

}

VOID
REPLACE::InitializeThings (
        )

/*++

Routine Description:

        Initializes the global variables that need initialization

Arguments:

    None.

Return Value:

    None.

Notes:

--*/

{

    //
        //      Initialize the path string buffers
        //
    _PathString1 = (LPWSTR)MALLOC( INITIAL_PATHSTRING_BUFFER_SIZE );
    _PathString2 = (LPWSTR)MALLOC( INITIAL_PATHSTRING_BUFFER_SIZE );

    _PathString1Size = _PathString2Size = INITIAL_PATHSTRING_BUFFER_SIZE;

    _Keyboard = NEW KEYBOARD;

    if ( !_PathString1 || !_PathString2 || !_Keyboard ) {
            DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
    }

    //
    //      initialize the keyboard and set ctrl-c handling
    //
    _Keyboard->Initialize();
    _Keyboard->EnableBreakHandling();

    //
    //      Initialize our data
    //
    _SourcePath             =       NULL;
    _DestinationPath        =       NULL;
    _FilesAdded             =       0;
    _FilesReplaced          =       0;
    _SourceDirectory        =       NULL;
    _Pattern                        =       NULL;
    _FilesInSrc             =       NULL;

    _AddSwitch = FALSE;   // use by DisplayMessageAndExit before any
                          // of those boolean _*Switch is being initialized

}

VOID
REPLACE::DeallocateThings (
        )

/*++

Routine Description:

        Deallocates the stuff that was initialized in InitializeThings()

Arguments:

    None.

Return Value:

    None.

Notes:

--*/

{

    DELETE( _FilesInSrc );
    DELETE( _SourceDirectory );
    DELETE( _Pattern );
    DELETE( _Keyboard );

    FREE( _PathString1 );
    FREE( _PathString2 );

}

BOOLEAN
REPLACE::DoReplace (
        )

/*++

Routine Description:

        This is the function that performs the Replace.

Arguments:

    None.

Return Value:

        TRUE

Notes:

--*/

{

    PFSN_DIRECTORY  DestinationDirectory;
    FSN_FILTER              Filter;
    WCHAR                   Char;

    //
    //      Get the source directory object and the pattern that we will use
    //      for file matching.
    //
    GetDirectoryAndPattern( _SourcePath, &_SourceDirectory, &_Pattern );

    DebugPtrAssert( _SourceDirectory );
    DebugPtrAssert( _Pattern );

    //
    //      Get the destination directory
    //
    GetDirectory( _DestinationPath, &DestinationDirectory );

    DebugPtrAssert( DestinationDirectory );

    //
    //      Wait if requested
    //
    if ( _WaitSwitch ) {

            DisplayMessage( REPLACE_MESSAGE_PRESS_ANY_KEY );
            AbortIfCtrlC();

            //
            //      All input is in raw mode.
            //
            _Keyboard->DisableLineMode();
            GetStandardInput()->ReadChar( &Char );
            _Keyboard->EnableLineMode();

            GetStandardOutput()->WriteChar( Char );
            GetStandardOutput()->WriteChar( (WCHAR)'\r');
            GetStandardOutput()->WriteChar( (WCHAR)'\n');

            //
            //      Check for ctrl-c
            //
            if ( Char == CTRL_C ) {
                    exit ( EXIT_PATH_NOT_FOUND );
            }
    }

    //
    //      Get an array containing all the files in the source directory
    //      that match the pattern.
    //
    //      This is so that Replacer() does not have to get the same
    //      information over and over when the Subdir switch is set.
    //
    _FilesInSrc = GetFileArray( _SourceDirectory, _Pattern );
    DebugPtrAssert( _FilesInSrc );

    if ( _SubdirSwitch ) {

            //
            //      First, replace the files in the directory specified
            //
            Replacer( this, DestinationDirectory, NULL );

            Filter.Initialize();
            Filter.SetAttributes( (FSN_ATTRIBUTE)FILE_ATTRIBUTE_DIRECTORY );

            //
            //      Now traverse the destination directory, calling the
            //      replacer function for each subdirectory.
            //
            DestinationDirectory->Traverse( this,
                                                                            &Filter,
                                                                            NULL,
                                                                            REPLACE::Replacer );
    } else {

            //
            //      Call the replace function, which takes care of replacements
            //
            Replacer(this,  DestinationDirectory, NULL );
    }
    DELETE( DestinationDirectory );

    return TRUE;

}

VOID
REPLACE::GetDirectoryAndPattern(
   IN    PPATH       Path,
   OUT   PFSN_DIRECTORY *Directory,
    OUT     PWSTRING        *Pattern
   )

/*++

Routine Description:

        Given a path, this function obtains a directory object and a pattern.

        Normally, the pattern is the filename portion of the path, but if the
        entire path refers to a directory, then the pattern is "*.*"

Arguments:

        Path            -       Supplies pointer to path
        Directory       -       Supplies pointer to pointer to directory
        Pattern         -       Supplies pointer to pointer to pattern

Return Value:

        TRUE

Notes:

--*/

{
    PATH           TmpPath;
    PWSTRING            Name;
    PFSN_DIRECTORY    Dir;
    PWSTRING            Ptrn;

    DebugAssert( Path );
    DebugAssert( Directory );
    DebugAssert( Pattern );

    //
    // If the name passed is a directory, it is an error.
    // Otherwise, split the path into Directory and Pattern
    // portions.
    //
    Dir = SYSTEM::QueryDirectory( Path );

    if ( Dir ||
         (Name = Path->QueryName()) == NULL ||
         (Ptrn = Name->QueryString()) == NULL ) {

        DisplayMessageAndExit( REPLACE_ERROR_NO_FILES_FOUND,
                               Path->GetPathString(),
                               EXIT_FILE_NOT_FOUND );

    } else {

        // We're finished with Name.
        //
        DELETE( Name );

        //
        // Get the directory
        //
        TmpPath.Initialize( Path, TRUE );
        TmpPath.TruncateBase();

        Dir = SYSTEM::QueryDirectory( &TmpPath );

        if ( !Dir ) {

            DisplayMessageAndExit( REPLACE_ERROR_PATH_NOT_FOUND,
                                   Path->GetPathString(),
                                   EXIT_PATH_NOT_FOUND );
        }

        *Directory = Dir;
        *Pattern   = Ptrn;
    }
}

VOID
REPLACE::GetDirectory(
        IN              PCPATH                  Path,
        OUT     PFSN_DIRECTORY  *Directory
        )

/*++

Routine Description:

        Makes a directory out of a path.

Arguments:

        Path            -       Supplies pointer to path
        Directory       -       Supplies pointer to pointer to directory

Return Value:

        TRUE

Notes:

--*/

{
    PFSN_DIRECTORY  Dir;


    if ( !(Dir = SYSTEM::QueryDirectory( Path )) ) {

            DisplayMessageAndExit( REPLACE_ERROR_PATH_NOT_FOUND,
                                                       Path->GetPathString(),
                                                       EXIT_PATH_NOT_FOUND );
    }

    *Directory = Dir;

}

PARRAY
REPLACE::GetFileArray(
   IN    PFSN_DIRECTORY Directory,
    IN      PWSTRING        Pattern
   )

/*++

Routine Description:

        Gets an array of those files in a directory matching a pattern.

Arguments:

        Directory       -       Supplies pointer to directory
        Pattern         -       Supplies pointer to pattern

Return Value:

        Pointer to the array of files

Notes:

--*/
{

    PARRAY          Array;
    FSN_FILTER      Filter;

    DebugPtrAssert( Directory );
    DebugPtrAssert( Pattern );

    Filter.Initialize();
    Filter.SetFileName( Pattern );
    Filter.SetAttributes( (FSN_ATTRIBUTE)0, (FSN_ATTRIBUTE)0, (FSN_ATTRIBUTE)FILE_ATTRIBUTE_DIRECTORY );

    Array = Directory->QueryFsnodeArray( &Filter );

    DebugPtrAssert( Array );

    return Array;

}

BOOLEAN
REPLACE::Replacer (
        IN              PVOID           This,
        IN OUT  PFSNODE         DirectoryNode,
        IN              PPATH           DummyPath
        )
/*++

Routine Description:

        This is the heart of Replace. Given a destination directory, it
        performs the replacement/additions according to the global switches
        and the SourceDirectory and Pattern.

Arguments:

        This                    -       Supplies pointer to the REPLACE object
        Node                    -       Supplies pointer to the directory node.
        DummyPath               -       Required by FSN_DIRECTORY::Traverse(), must be
                                                NULL.

Return Value:

        BOOLEAN -       TRUE if operation successful.
                                FALSE otherwise

Notes:

--*/

{

    DebugAssert( DummyPath == NULL );
    DebugAssert( DirectoryNode->IsDirectory() );

    ((PREPLACE)This)->AbortIfCtrlC();

    if ( ((PREPLACE)This)->_AddSwitch ) {
        return ((PREPLACE)This)->AddFiles( (PFSN_DIRECTORY)DirectoryNode );
    } else {
        return ((PREPLACE)This)->ReplaceFiles( (PFSN_DIRECTORY)DirectoryNode );
    }
}

BOOLEAN
REPLACE::AddFiles (
        IN OUT  PFSN_DIRECTORY  DestinationDirectory
        )
/*++

Routine Description:

        Adds those      files from the SourceDirectory that match Pattern to the
        DestinationDirectory. The array of files is already in the
        FilesInSrc array.

Arguments:

        DestinationDirectory    -       Supplies pointer to destination
                                                                directory.

Return Value:

        BOOLEAN -       TRUE if operation successful.
                                FALSE otherwise

Notes:

--*/

{

    PARRAY_ITERATOR   Iterator;
    PFSN_FILE         File;
    PFSN_FILE         FileToCreate;
    PATH              DestinationPath;
    PWSTRING          Name;

    DebugPtrAssert( DestinationDirectory );
    DebugPtrAssert( _FilesInSrc );

    //
    //      Get destination path
    //
    DestinationPath.Initialize( DestinationDirectory->GetPath() );

    //
    //      Obtain an iterator for going thru the files
    //
    Iterator = ( PARRAY_ITERATOR )_FilesInSrc->QueryIterator( );
    if (Iterator == NULL) {
        DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
        return FALSE;       // help lint
    }

    //
    //      For each file in the array, see if it exists in the destination
    //      directory, and if it does not, then copy it.
    //
    while ( File =  (PFSN_FILE)Iterator->GetNext() ) {

        DebugAssert( !(((PFSNODE)File)->IsDirectory()) );

        Name = File->QueryName();
        if (Name == NULL) {
            DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
            return FALSE;       // help lint
        }

        //
        //      Form the path in the target file
        //
        DestinationPath.AppendBase( Name );

        DELETE( Name );

        //
        //      See if the file exists
        //
        FileToCreate = SYSTEM::QueryFile( &DestinationPath );

        //
        //      If the file does not exist, then it has to be added
        //
        if ( !FileToCreate ) {

            if ( !_PromptSwitch || Prompt( REPLACE_MESSAGE_ADD_YES_NO, &DestinationPath ) ) {

                DisplayMessage( REPLACE_MESSAGE_ADDING, NORMAL_MESSAGE, "%W", DestinationPath.GetPathString() );

                CopyTheFile( File->GetPath(), &DestinationPath );

                _FilesAdded++;
            }

        }

        DELETE( FileToCreate );

        //
        //      Set the destination path back to what it originally was
        //      ( i.e. directory specification, no file ).
        //
        DestinationPath.TruncateBase();

    }
    DELETE( Iterator );

    return TRUE;
}

BOOLEAN
REPLACE::ReplaceFiles (
        IN OUT  PFSN_DIRECTORY  DestinationDirectory
        )
/*++

Routine Description:

        Replaces those files in the DestinationDirectory that match Pattern
        by the corresponding files in SourceDirectory.

Arguments:

        DestinationDirectory    -       Supplies pointer to destination
                                                                directory.

Return Value:

        BOOLEAN -       TRUE if operation successful.
                        FALSE otherwise

Notes:

--*/

{

    PARRAY_ITERATOR     Iterator;
    PFSN_FILE           File;
    PFSN_FILE           FileToReplace;
    PATH                DestinationPath;
    PWSTRING            Name;
    PTIMEINFO           TimeSrc;
    PTIMEINFO           TimeDst;
    BOOLEAN             Proceed = TRUE;

    DebugPtrAssert( DestinationDirectory );
    DebugPtrAssert( _FilesInSrc );

    //
    //      Get destination path
    //
    DestinationPath.Initialize( DestinationDirectory->GetPath() );

    //
    //      Obtain an iterator for going thru the files
    //
    Iterator = ( PARRAY_ITERATOR )_FilesInSrc->QueryIterator( );
    if (Iterator == NULL) {
        DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
        return FALSE;       // help lint
    }

    //
    //      For each file in the array, see if it exists in the destination
    //      directory, and if it does, replace it
    //
    while ( File =  (PFSN_FILE)Iterator->GetNext() ) {

        AbortIfCtrlC();

        DebugAssert( !(((PFSNODE)File)->IsDirectory()) );

        Name = File->QueryName();
        if (Name == NULL) {
            DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
            return FALSE;       // help lint
        }

        //
        //      Form the path in the target file
        //
        DestinationPath.AppendBase( Name );

        DELETE( Name );

        //
        //      See if the file exists
        //
        FileToReplace = SYSTEM::QueryFile( &DestinationPath );


        if ( FileToReplace ) {

            //
            //      If the CompareTime switch is set, then we only proceed if
            //      the destination file is older than the source file.
            //
            if ( _CompareTimeSwitch ) {

                TimeSrc = File->QueryTimeInfo();
                TimeDst = FileToReplace->QueryTimeInfo();

                if (TimeSrc == NULL) {
                    DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
                    return FALSE;       // help lint
                }
                if (TimeDst == NULL) {
                    DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );
                    return FALSE;       // help lint
                }

                Proceed = *TimeDst < *TimeSrc;

                DELETE( TimeSrc );
                DELETE( TimeDst );

            }

            if ( Proceed ) {

                //
                //      We replace the file if it is NOT read-only
                //      (unless the ReadOnly switch is set )
                //
                if ( _ReadOnlySwitch || !(FileToReplace->IsReadOnly()) ) {

                    if ( !_PromptSwitch || Prompt( REPLACE_MESSAGE_REPLACE_YES_NO, &DestinationPath ) ) {

                        DisplayMessage( REPLACE_MESSAGE_REPLACING, NORMAL_MESSAGE, "%W", DestinationPath.GetPathString() );

                        //
                        //      If the file is read-only, we reset the read-only attribute
                        //      before copying.
                        //
                        if ( FileToReplace->IsReadOnly() ) {
                            FileToReplace->ResetReadOnlyAttribute();
                        }

                        CopyTheFile( File->GetPath(), &DestinationPath );

                        _FilesReplaced++;
                    }
                } else {

                    //
                    //      The file is read-only but the ReadOnly flag was
                    //      not set, we error out.
                    //
                    DisplayMessageAndExit( REPLACE_ERROR_ACCESS_DENIED,
                                           DestinationPath.GetPathString(),
                                           EXIT_ACCESS_DENIED );
                }
            }
        }

        DELETE( FileToReplace );

        //
        //      Set the destination path back to what it originally was
        //      ( i.e. directory specification, no file name part ).
        //
        DestinationPath.TruncateBase();

    }

    DELETE( Iterator );

    return TRUE;
}

BOOLEAN
REPLACE::Prompt (
        IN      MSGID           MessageId,
        IN      PCPATH          Path
        )

/*++

Routine Description:

        Gets confirmation from the user about a file to be added/replaced

Arguments:

        MessageId       -       Supplies the Id of the message to use for prompting
        Path            -       Supplies path to use as parameter for the message.

Return Value:

        BOOLEAN -       TRUE if the user confirmed the add/replace
                                FALSE otherwise

--*/

{

    DisplayMessage( MessageId, NORMAL_MESSAGE, "%W", Path->GetPathString() );
    return _Message.IsYesResponse();

}

BOOLEAN
REPLACE::CopyTheFile (
        IN      PCPATH          SrcPath,
        IN      PCPATH          DstPath
        )

/*++

Routine Description:

        Copies a file

Arguments:

        SrcPath         -       Supplies path of source file
        DstFile         -       Supplies path of destination file

Return Value:

        BOOLEAN -       TRUE

--*/

{

    ULONG   Size;

    DebugPtrAssert( SrcPath );
    DebugPtrAssert( DstPath );

    //
    //      Make sure that the buffers are big enough to hold the
    //      paths
    //
    Size = (SrcPath->GetPathString()->QueryChCount() + 1) * 2;
    if ( Size > _PathString1Size ) {
    _PathString1 = (LPWSTR)REALLOC( _PathString1, (unsigned int)Size );
            DebugPtrAssert( _PathString1 );
            _PathString1Size = Size;
    }

    Size = (DstPath->GetPathString()->QueryChCount() + 1) * 2;
    if ( Size > _PathString2Size ) {
    _PathString2 = (LPWSTR)REALLOC( _PathString2, (unsigned int)Size );
            DebugPtrAssert( _PathString2 );
            _PathString2Size = Size;
    }

    if ( !_PathString1 || !_PathString2 ) {
            DisplayMessageAndExit( REPLACE_ERROR_NO_MEMORY, NULL, EXIT_NO_MEMORY );

    }

    //
    //  Convert the paths to LPWSTR so that we can call CopyFile()
    //
    SrcPath->GetPathString()->QueryWSTR( 0, TO_END, _PathString1, _PathString1Size/sizeof(WCHAR) );
    DstPath->GetPathString()->QueryWSTR( 0, TO_END, _PathString2, _PathString2Size/sizeof(WCHAR) );

    //
    //      Now do the copy
    //
    if ( !CopyFile( _PathString1, _PathString2, FALSE ) ) {

            ExitWithError( GetLastError() );

    }

    return TRUE;

}