windows-server-2003/inetsrv/query/cicat/update.cxx

//+---------------------------------------------------------------------------
//
//  Microsoft Windows
//  Copyright (C) Microsoft Corporation, 1991 - 2000.
//
//  File:   UPDATE.CXX
//
//  Contents:   Content Index Update
//
//  History:    19-Mar-92   AmyA        Created.
//
//----------------------------------------------------------------------------

#include <pch.cxx>
#pragma hdrstop

#include <imprsnat.hxx>
#include <pathpars.hxx>
#include <cifrmcom.hxx>
#include <lcase.hxx>

#include "cicat.hxx"
#include "update.hxx"

//+---------------------------------------------------------------------------
//
//  Class:      CImpersonatedFindFirst
//
//  Purpose:    A class that is capable of repeatedly trying to do a find
//              first until there is success or is not retryable any more.
//              Changes impersonation between attempts.
//
//  History:    7-18-96   srikants   Created
//
//----------------------------------------------------------------------------

class CImpersonatedFindFirst: public PImpersonatedWorkItem
{

public:

    CImpersonatedFindFirst( const CFunnyPath & funnyPath, HANDLE & h )
            : PImpersonatedWorkItem( funnyPath.GetActualPath() ),
              _funnyPath( funnyPath ),
              _h(h)
    {

    }


    BOOL OpenFindFirst( CImpersonateRemoteAccess & remoteAccess );

    BOOL DoIt();        // virtual

private:

    HANDLE &            _h;
    const CFunnyPath &  _funnyPath;
};

//+---------------------------------------------------------------------------
//
//  Member:     CImpersonatedFindFirst::OpenFindFirst
//
//  Synopsis:   Opens the first first handle, impersonating as necessary.
//
//  Arguments:  [remoteAccess] -
//
//  Returns:    TRUE if successful; FALSE o/w
//
//  History:    7-18-96   srikants   Created
//
//----------------------------------------------------------------------------

BOOL CImpersonatedFindFirst::OpenFindFirst(
                                CImpersonateRemoteAccess & remoteAccess )
{
    BOOL fSuccess = TRUE;

    TRY
    {
        ImpersonateAndDoWork( remoteAccess );
    }
    CATCH( CException, e )
    {
        ciDebugOut(( DEB_ERROR, "OpenFindFirst (%ws) failed with error (0x%X)\n",
                     _funnyPath.GetPath(), e.GetErrorCode() ));
        fSuccess = FALSE;
    }
    END_CATCH

    return fSuccess;
}

//+---------------------------------------------------------------------------
//
//  Member:     CImpersonatedFindFirst::DoIt
//
//  Synopsis:   The worker method that does the work in the context of
//              impersonation.
//
//  Returns:    TRUE if successful; FALSE if should be retried; THROWS
//              otherwise.
//
//  History:    7-18-96   srikants   Created
//
//----------------------------------------------------------------------------

BOOL CImpersonatedFindFirst::DoIt()
{
    //
    // Open directory
    //

    NTSTATUS Status =
        CiNtOpenNoThrow( _h,
                         _funnyPath.GetPath(),
                         FILE_LIST_DIRECTORY | SYNCHRONIZE,
                         FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                         FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT );

    if ( !NT_SUCCESS(Status) )
    {
        if ( IsRetryableError( Status ) )
            return FALSE;
        else
        {
            THROW( CException( Status ) );
        }
    }

    return TRUE;
} //DoIt

//+---------------------------------------------------------------------------
//
//  Member:     CTraverse::CTraverse
//
//  Synopsis:   Constructor of the CTraverse class.
//
//  Arguments:  [fAbort]   - A reference to an abort triggering variable.
//
//  History:    3-15-96   srikants   Split from CUpdate
//
//----------------------------------------------------------------------------

CTraverse::CTraverse( CiCat & cat,
                      BOOL & fAbort,
                      BOOL fProcessRoot )
        : _cat( cat ),
          _fAbort(fAbort),
          _fProcessRoot(fProcessRoot),
          _cProcessed( 0 ),
          _xbBuf( FINDFIRST_SIZE ),
          _pCurEntry( 0 ),
          _status( STATUS_SUCCESS )
{
}

//+---------------------------------------------------------------------------
//
//  Member:     CTraverse::DoIt
//
//  Synopsis:   Traverses the tree from the given root and invokes the
//              "ProcessFile" method on all the files found. Also, before
//              starting to traverse a directory, it calls the
//              "IsEligibleForTraversal()" method on that.
//
//  Arguments:  [lcaseFunnyRootPath] - The path to traverse.
//
//  History:    3-15-96   srikants   Split from CUpdate constructor
//
//  Notes:
//
//----------------------------------------------------------------------------

void CTraverse::DoIt( const CLowerFunnyPath & lcaseFunnyRootPath )
{
    Push( lcaseFunnyRootPath );

    if ( _fProcessRoot )
    {
        Win4Assert( 0 == _pCurEntry );

        // Note this is a bit of a hack.  Only the attributes field is valid.

        _pCurEntry = (CDirEntry *)_xbBuf.GetPointer();

        ULONG ulAttrib = 0;

        if ( CImpersonateRemoteAccess::IsNetPath( lcaseFunnyRootPath.GetActualPath() ) )
        {
            CImpersonateRemoteAccess remote( _cat.GetImpersonationTokenCache() );
            CImpersonatedGetFileAttr getAttr( lcaseFunnyRootPath );

            getAttr.DoWork( remote );
            ulAttrib = getAttr.GetAttr();
        }
        else
        {
            ulAttrib = GetFileAttributes( lcaseFunnyRootPath.GetPath() );
        }

        _pCurEntry->SetAttributes( ulAttrib );

        //
        // If we got an error value for file attributes, then substitute zero
        // because we don't want the directory bit to be turned on
        //

        if ( INVALID_FILE_ATTRIBUTES == _pCurEntry->Attributes() )
            _pCurEntry->SetAttributes( 0 );

        if ( !ProcessFile( lcaseFunnyRootPath ) )
            return;
    }

    CImpersonateRemoteAccess remote( _cat.GetImpersonationTokenCache() );

    for (;;)
    {
        XPtr<CLowerFunnyPath> xLowerFunnyPath;

        if ( !Pop( xLowerFunnyPath ) )
            break;

        if ( !Traverse(xLowerFunnyPath, remote))
            break;
    }
} //DoIt

//+---------------------------------------------------------------------------
//
//  Member:     CTraverse::Traverse
//
//  Synopsis:   Traverses the specified directory.
//
//  Arguments:  [dir] -
//
//  History:    3-15-96   srikants   Split from CUpdate::Traverse
//
//----------------------------------------------------------------------------

BOOL CTraverse::Traverse (XPtr<CLowerFunnyPath> & xLowerFunnyPath, CImpersonateRemoteAccess & remote )
{
    if ( !IsEligibleForTraversal( xLowerFunnyPath.GetReference() ) )
    {
        ciDebugOut (( DEB_ITRACE, "Traverse skipping %ws\n", xLowerFunnyPath->GetActualPath() ));
        return TRUE;
    }

    TraversalIdle();

    CFullPath fullPath( xLowerFunnyPath->GetActualPath(), xLowerFunnyPath->GetActualLength() );

    ciDebugOut (( DEB_ITRACE, "Traversing %ws\n", fullPath.GetBuf()));

    ULONG cSkip = 0;

    HANDLE h;

    if ( CImpersonateRemoteAccess::IsNetPath( xLowerFunnyPath->GetActualPath() ) )
    {
        CImpersonatedFindFirst findFirst( fullPath.GetFunnyPath(), h );

        if ( !findFirst.OpenFindFirst( remote ) )
            return TRUE;
    }
    else
    {
        //
        // Open directory
        //

        NTSTATUS Status =
            CiNtOpenNoThrow( h,
                             xLowerFunnyPath->GetPath(),
                             FILE_LIST_DIRECTORY | SYNCHRONIZE,
                             FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
                             FILE_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT | FILE_OPEN_FOR_BACKUP_INTENT );

        if ( !NT_SUCCESS(Status) )
            return TRUE;
    }

    SHandle xHandle(h);

    //
    // First enumeration
    //

    IO_STATUS_BLOCK IoStatus;
    NTSTATUS Status;

    Status = NtQueryDirectoryFile( h,                      // File
                                   0,                      // Event
                                   0,                      // APC routine
                                   0,                      // APC context
                                   &IoStatus,              // I/O Status
                                   _xbBuf.GetPointer(),    // Buffer
                                   _xbBuf.SizeOf(),        // Buffer Length
                                   FileBothDirectoryInformation,
                                   0,                      // Multiple entry
                                   0,                      // Filename
                                   1 );                    // Restart scan

    if ( NT_SUCCESS(Status) )
        Status = IoStatus.Status;

    //
    // If there are no more files or we don't have access to any more files
    // in this branch of the tree, just continue traversing.  Otherwise throw.
    //

    if ( !NT_SUCCESS(Status) )
    {
        if ( STATUS_NO_MORE_FILES == Status ||
             STATUS_NO_SUCH_FILE  == Status ||
             STATUS_ACCESS_DENIED == Status )
            return TRUE;

        THROW( CException( Status ) );
    }

    _pCurEntry = (CDirEntry *)_xbBuf.GetPointer();
    BOOL fMore = TRUE;

    ULONG ulScanBackoff = _cat.GetRegParams()->GetScanBackoff();

    do
    {
        //
        // Sleep for a while to let other I/O get through if appropriate.
        //
        // For reference, with 105,000 files on a free build, here are the
        // scan times ( for mod of 50 and sleep(200) * ulScanBackoff )
        //
        // ScanBackoff  Time (min:sec)
        // -----------  --------------
        //  0            8:40
        //  1           18:03
        //  3           43:11
        //

        if ( 0 != ulScanBackoff )
        {
            if ( ulScanBackoff > CI_SCAN_BACKOFF_MAX_RANGE )
            {
                //
                // These values are reserved for future use.
                //
            }
            else if ( ( _cProcessed % 50 ) == 0 )
            {
                for ( unsigned i = 0; !_fAbort && i < ulScanBackoff; i++ )
                    Sleep( 100 );

                //
                // If we're running ahead of filtering, then let's take a break.
                // What's the point in running up a big change log for no reason?
                //
                // Attempt to keep primary and secondary store pages in memory.
                // The primary store keeps 1489 records per 64k page and the
                // secondary by default keeps 140.  By keeping the scan
                // thread only a little ahead of the filter thread we
                // thrash less.
                //

                unsigned cLoops = 0;

                while ( !_fAbort )
                {
                    CI_STATE State;
                    State.cbStruct = sizeof State;

                    SCODE sc = _cat.CiState( State );

                    if ( FAILED(sc) ||
                         ( (State.cDocuments - State.cSecQDocuments) < 200 &&
                           ( 0 == (State.eState & ( CI_STATE_HIGH_IO |
                                                    CI_STATE_LOW_MEMORY |
                                                    CI_STATE_USER_ACTIVE ) ) ) ) )
                        break;

                    //
                    // Only call TraverseIdle if filtering has been stalled
                    // for a long time -- every 60 seconds or so.
                    //

                    cLoops++;

                    if ( 0 == ( cLoops % 30 ) )
                        TraversalIdle( TRUE ); // TRUE --> Stalled (not scanning)

                    //
                    // Sleep for a few of seconds, checking for abort.
                    //

                    for ( unsigned i = 0; !_fAbort && i < 3; i++ )
                        Sleep( 100 );
                }
            }
        }

        _cProcessed++;

        //
        // Get out?
        //

        if ( _fAbort )
        {
            ciDebugOut(( DEB_ITRACE, "Aborting scan in the middle\n" ));
            break;
        }

        fullPath.MakePath( _pCurEntry->Filename(), _pCurEntry->FilenameSize() / sizeof(WCHAR) );

        BOOL fSkipFile = FALSE;

        // If it's a directory and not a reparse point, push it on the stack

        if ( ( 0 != ( _pCurEntry->Attributes() & FILE_ATTRIBUTE_DIRECTORY ) ) &&
             ( 0 == ( _pCurEntry->Attributes() & FILE_ATTRIBUTE_REPARSE_POINT ) ) )
        {
            if ( _pCurEntry->Filename()[0] == L'.' &&
                 ( _pCurEntry->FilenameSize() == sizeof(WCHAR) ||
                   (_pCurEntry->Filename()[1] == L'.' && _pCurEntry->FilenameSize() == sizeof(WCHAR) * 2 ) ) )
            {
                fSkipFile = TRUE;
            }
            else
            {
                // Neither "." nor ".." directories

                Push( fullPath.GetFunnyPath() );
            }
        }

        if ( !fSkipFile )
            if ( !ProcessFile( fullPath.GetFunnyPath() ) )
            {
                _status = HRESULT_FROM_WIN32( GetLastError() );
                return FALSE;
            }

        _pCurEntry = _pCurEntry->Next();

        if ( 0 == _pCurEntry )
        {
            Status = NtQueryDirectoryFile( h,                      // File
                                           0,                      // Event
                                           0,                      // APC routine
                                           0,                      // APC context
                                           &IoStatus,              // I/O Status
                                           _xbBuf.GetPointer(),    // Buffer
                                           _xbBuf.SizeOf(),        // Buffer Length
                                           FileBothDirectoryInformation,
                                           0,                      // Multiple entry
                                           0,                      // Filename
                                           0 );                    // Continue scan

            if ( NT_SUCCESS(Status) )
                Status = IoStatus.Status;

            if ( NT_SUCCESS( Status ) )
                _pCurEntry = (CDirEntry *)_xbBuf.GetPointer();
            else
                fMore = FALSE;
        }
    } while ( fMore );

    if ( !_fAbort )
    {
        if ( STATUS_NO_SUCH_FILE == Status )
            Status = STATUS_NO_MORE_FILES;

        _status = Status;

        return STATUS_NO_MORE_FILES == _status;
    }

    return FALSE;
}


//+-------------------------------------------------------------------------
//
//  Member:     CUpdate::CUpdate, public
//
//  Synopsis:   Perform update of scope.  All work done from constructor.
//
//  Arguments:  [cat]                -- Catalog
//              [lcaseFunnyRootPath] -- Root of scope
//              [PartId]             -- Partition id
//              [fIncrem]            -- TRUE if this is an incremental update
//
//  History:    04-Jan-96  KyleP    Added header
//
//--------------------------------------------------------------------------

CUpdate::CUpdate ( CiCat& cat,
                   ICiManager & ciManager,
                   const CLowerFunnyPath & lcaseFunnyRootPath,
                   PARTITIONID PartId,
                   BOOL fIncrem,
                   BOOL fDoDeletions,
                   BOOL & fAbort,
                   BOOL fProcessRoot )
        : CTraverse( cat, fAbort, fProcessRoot ),
          _ciManager(ciManager),
          _cDoc(0),
          _PartId(PartId),
          _fIncrem(fIncrem),
          _fDoDeletions(fDoDeletions)
{
    ciDebugOut(( DEB_ITRACE, "CUpdate::CUpdate root: '%ws', fAbort: %d\n",
                 lcaseFunnyRootPath.GetActualPath(), fAbort ));

    BOOL fRootDeleted = FALSE;

    //
    // If the rootPath is a network path, it is possible that the connection
    // is down. _cat.StartUpdate() is a fairly expensive operation because it
    // involves scanning the whole property store.
    // Before doing any further processing, just check if we can
    // open the path and get some information on it.
    //
    // Also, check that the root of the scope exists.  If not, delete the
    // files in the scope
    //

    if ( CImpersonateRemoteAccess::IsNetPath( lcaseFunnyRootPath.GetActualPath() ) )
    {
        CImpersonateRemoteAccess remote( _cat.GetImpersonationTokenCache() );

        TRY
        {
            CImpersonatedGetAttr    getAttr( lcaseFunnyRootPath );
            getAttr.DoWork( remote );
        }
        CATCH( CException, e )
        {
            ciDebugOut(( DEB_WARN,
                         "CUpdate::CUpdate(a) can't get attrinfo: %#x, for %ws\n",
                         e.GetErrorCode(),  lcaseFunnyRootPath.GetActualPath()));
            if ( HRESULT_FROM_WIN32( ERROR_FILE_NOT_FOUND ) != e.GetErrorCode() ||
                 HRESULT_FROM_WIN32( ERROR_PATH_NOT_FOUND ) != e.GetErrorCode())
                RETHROW();

            fRootDeleted = TRUE;
        }
        END_CATCH;
    }
    else
    {
        DWORD dw = GetFileAttributes( lcaseFunnyRootPath.GetPath() );
        if ( 0xffffffff == dw )
        {
            DWORD dwErr = GetLastError();
            ciDebugOut(( DEB_WARN,
                         "CUpdate::CUpdate(b) can't get attrinfo: %d, for %ws\n",
                         dwErr, lcaseFunnyRootPath.GetPath()));
            if ( ERROR_FILE_NOT_FOUND == dwErr || ERROR_PATH_NOT_FOUND == dwErr )
                fRootDeleted = TRUE;
        }
    }

    _docList.SetPartId ( _PartId );
    _cat.StartUpdate( &_timeLastUpd, lcaseFunnyRootPath.GetActualPath(), fDoDeletions, eScansArray );

    // Make sure EndProcessing deletes all the files in the scope

    if ( fRootDeleted )
    {
        _status = STATUS_NO_MORE_FILES;
        return;
    }

    //
    // This is a bit of a kludge.  If we're doing an incremental update, we
    // will not *update* the root, but we need to mark it as seen so it
    // won't get deleted.
    //

    if ( _fDoDeletions )
    {
        WORKID wid = _cat.PathToWorkId( lcaseFunnyRootPath, eScansArray, fileIdInvalid );

        //
        // Workid is invalid for root, such as f:\
        //
        //NOTE: LokSetSeen is called by PathToWorkId
        //if ( wid != widInvalid )
        //    _cat.Touch( wid, eScansArray );
    }

#   if CIDBG == 1
        SYSTEMTIME time;
        RtlZeroMemory( &time, sizeof(time) );
        FileTimeToSystemTime( &_timeLastUpd, &time );

        TIME_ZONE_INFORMATION tzinfo;
        GetTimeZoneInformation( &tzinfo );

        SYSTEMTIME timeLocal;
        SystemTimeToTzSpecificLocalTime( &tzinfo, &time, &timeLocal );

        ciDebugOut(( DEB_ITRACE, "Begin update.  Last update %4d/%02d/%02d  %02d:%02d:%02d.%d\n",
                     timeLocal.wYear,
                     timeLocal.wMonth,
                     timeLocal.wDay,
                     timeLocal.wHour,
                     timeLocal.wMinute,
                     timeLocal.wSecond,
                     timeLocal.wMilliseconds ));
#   endif

    DoIt( lcaseFunnyRootPath );
} //CUpdate

//+-------------------------------------------------------------------------
//
//  Member:     CUpdate::EndProcessing, public
//
//  Synopsis:   Flush final updates to catalog.
//
//  History:    04-Jan-96  KyleP    Added header
//
//--------------------------------------------------------------------------
void CUpdate::EndProcessing()
{
    ciDebugOut(( DEB_ITRACE,
                 "CUpdate::EndProcessing, _fAbort: %d, _status %#x\n",
                 _fAbort,
                 _status ));
    if ( !_fAbort )
    {
        if ( _cDoc != 0 )
        {
            _docList.LokSetCount ( _cDoc );
            _cat.AddDocuments( _docList );
            _docList.LokClear();
            _docList.SetPartId ( _PartId );
            _cDoc = 0;
        }

        if ( STATUS_NO_MORE_FILES == _status )
        {
            _cat.EndUpdate( _fDoDeletions, eScansArray );
        }
        else if ( STATUS_SUCCESS != _status )
        {
            ciDebugOut(( DEB_ERROR, "Error %#x while traversing\n",
                         _status ));
            THROW( CException( _status ) );
        }
    }
} //EndProcessing

//+---------------------------------------------------------------------------
//
//  Member:     CUpdate::ProcessFile
//
//  Synopsis:   Processes the given file and adds it to the list of changed
//              documents if necessary.
//
//  Arguments:  [lcaseFunnyPath] -  Path of the file to be processed.
//
//  Returns:    TRUE if successful; FALSE o/w
//
//  History:    3-15-96   srikants   Split from CUpdate::Traverse
//
//----------------------------------------------------------------------------

BOOL CUpdate::ProcessFile( const CLowerFunnyPath & lcaseFunnyPath )
{
    if (lcaseFunnyPath.IsRemote()) 
    {
        // Need to impersonate only for the remote case
        CImpersonateSystem impersonate;

        return ProcessFileInternal(lcaseFunnyPath);
    }
    else
       return ProcessFileInternal(lcaseFunnyPath);
} //ProcessFile


//+---------------------------------------------------------------------------
//
//  Member:     CUpdate::ProcessFileInternal
//
//  Synopsis:   Processes the given file and adds it to the list of changed
//              documents if necessary.
//
//  Arguments:  [lcaseFunnyPath] -  Path of the file to be processed.
//
//  Returns:    TRUE if successful; FALSE o/w
//
//  History:    3-15-96   srikants   Split from CUpdate::Traverse
//
//----------------------------------------------------------------------------

BOOL CUpdate::ProcessFileInternal( const CLowerFunnyPath & lcaseFunnyPath )
{
    //
    // Add path without committing it
    //

    FILETIME    ftLastSeen = { 0,0 };
    BOOL fNew;
    WORKID wid = _cat.PathToWorkId( lcaseFunnyPath,
                                    TRUE,
                                    fNew,
                                    _fIncrem ? &ftLastSeen : 0,
                                    eScansArray,
                                    fileIdInvalid );

    if (wid == widInvalid)
        return TRUE;

    //
    // Decide if file has been updated.
    //

    LONG result = -1;

    if ( _fIncrem && !fNew && !CiCat::IsMaxTime( ftLastSeen ) )
    {
        //
        // Use the bigger of the last seen time and time of last update
        // to compare the current time of the file.
        //

        if ( ( ( 0 != ftLastSeen.dwLowDateTime ) ||
               ( 0 != ftLastSeen.dwHighDateTime ) ) &&
             ( CompareFileTime( &_timeLastUpd, &ftLastSeen ) > 0 ) )
        {
            ftLastSeen = _timeLastUpd;
        }

        //
        // On FAT volumes, ChangeTime is always 0.  On NTFS, ChangeTime
        // can be more recent than ModifyTime (alias LastWriteTime) if the
        // change was to the ACLs of a file, in which case we need to
        // honor the change.
        //

        FILETIME ftLastDelta;
        if ( 0 == _pCurEntry->ChangeTime() )
            ftLastDelta = _pCurEntry->ModifyTimeAsFILETIME();
        else
            ftLastDelta = _pCurEntry->ChangeTimeAsFILETIME();

        result = CompareFileTime( &ftLastSeen, &ftLastDelta );
    }

    if (result < 0) // The file is newer than the catalog
    {
        ciDebugOut(( DEB_CAT, "Update %ws\n", lcaseFunnyPath.GetActualPath() ));

        _cat.WriteFileAttributes( wid, _pCurEntry->Attributes() );
        Add ( wid );
    }

    return TRUE;
} //ProcessFileInternal

//+---------------------------------------------------------------------------
//
//  Member:     CUpdate::IsEligibleForTraversal
//
//  Synopsis:   Checks to see if the current directory is eligible for
//              traversal.
//
//  Arguments:  [lcaseFunnyDir] -
//
//  History:    3-15-96   srikants   Created
//
//----------------------------------------------------------------------------

BOOL CUpdate::IsEligibleForTraversal( const CLowerFunnyPath & lcaseFunnyDir ) const
{
    return _cat.IsEligibleForFiltering( lcaseFunnyDir );
}

//+-------------------------------------------------------------------------
//
//  Member:     CUpdate::Add, public
//
//  Synopsis:   Add wid for update to doclist
//
//  Arguments:  [wid] -- Workid
//
//  History:    04-Jan-96  KyleP    Added header
//
//--------------------------------------------------------------------------

void CUpdate::Add( WORKID wid )
{
    _cat.Touch(wid, eScansArray);
    USN usn = 0;

    _docList.Set ( _cDoc, wid, usn, CI_VOLID_USN_NOT_ENABLED );
    _cDoc++;

    if (_cDoc == CI_MAX_DOCS_IN_WORDLIST)
    {
        _docList.LokSetCount ( _cDoc );

        _cat.AddDocuments( _docList );

        _docList.LokClear();
        _docList.SetPartId ( _PartId );
        _cDoc = 0;
    }
}



//+---------------------------------------------------------------------------
//
//  Member:     CRenameDir::CRenameDir
//
//  Synopsis:   Constructor
//
//  Arguments:  [strings]               --  Strings class
//              [lowerFunnyDirOldName]  -- Old directory
//              [lowerFunnyDirNewName]  -- Renamed directory
//              [fAbort]                -- Set to TRUE for aborting
//              [volumeId]              -- Volume id
//
//  History:    20-Mar-96    SitaramR   Created
//
//----------------------------------------------------------------------------

CRenameDir::CRenameDir( CiCat & cicat,
                        const CLowerFunnyPath & lowerFunnyDirOldName,
                        const CLowerFunnyPath & lowerFunnyDirNewName,
                        BOOL & fAbort,
                        VOLUMEID volumeId )
      : CTraverse( cicat, fAbort, TRUE ),
        _cicat(cicat),
        _volumeId(volumeId),
        _lowerFunnyDirOldName( lowerFunnyDirOldName )
{
    _lowerFunnyDirOldName.AppendBackSlash();
    _uLenDirOldName = _lowerFunnyDirOldName.GetActualLength();
    _uLenDirNewName = lowerFunnyDirNewName.GetActualLength();


    //
    // Recursive traversal of renamed dir (include the renamed dir also)
    //
    DoIt( lowerFunnyDirNewName );
}



//+---------------------------------------------------------------------------
//
//  Member:     CRenameDir::ProcessFile
//
//  Synopsis:   Update indexes to reflect new file name
//
//  Arguments:  [lcaseFunnyFileNewName]  -  File name
//
//  History:    20-Mar-96    SitaramR   Created
//
//----------------------------------------------------------------------------

BOOL CRenameDir::ProcessFile( const CLowerFunnyPath & lcaseFunnyFileNewName )
{
    unsigned uLenFileNewName = lcaseFunnyFileNewName.GetActualLength();
    Win4Assert( uLenFileNewName >= _uLenDirNewName );


    _lowerFunnyDirOldName.Truncate( _uLenDirOldName );
    _lowerFunnyDirOldName.AppendBackSlash();

    unsigned posNewFileNameStart = _uLenDirNewName;

    if ( L'\\' == lcaseFunnyFileNewName.GetActualPath()[posNewFileNameStart] )
    {
        posNewFileNameStart++;
    }
    _lowerFunnyDirOldName.AppendPath( lcaseFunnyFileNewName.GetActualPath() + posNewFileNameStart,
                                      uLenFileNewName - posNewFileNameStart );

    _lowerFunnyDirOldName.RemoveBackSlash();

    CLowerFunnyPath lcaseFunnyFileNewName2( lcaseFunnyFileNewName );
    lcaseFunnyFileNewName2.RemoveBackSlash();

    _cicat.RenameFile( _lowerFunnyDirOldName,
                       lcaseFunnyFileNewName2,
                       _pCurEntry->Attributes(),
                       _volumeId,
                       fileIdInvalid );

    return TRUE;
}