windows-server-2003/admin/pchealth/sr/restmap/reslist.cpp

/******************************************************************************
 *
 * Copyright (c) 1999 Microsoft Corporation
 *
 * Module Name:
 *    reslist.cpp
 *
 * Abstract:
 *    This file contains the implementation of Restore List.
 *
 * Revision History:
 *    Brijesh Krishnaswami  (brijeshk)    06/02/00 
 *        created
 *
 *
 ******************************************************************************/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include "restmap.h"
#include "reslist.h"
#include "shlwapi.h"
#include "utils.h"

#ifdef THIS_FILE
#undef THIS_FILE
#endif

static char __szTraceSourceFile[] = __FILE__;
#define THIS_FILE __szTraceSourceFile


#include "dbgtrace.h"


// copy acl

void
CopyAcl(CNode *pNode, BYTE *pbAcl, DWORD cbAcl, BOOL fAclInline)
{
    if (pbAcl) 
    { 
        HEAP_FREE(pNode->m_pbAcl); 
        pNode->m_pbAcl = (BYTE *) HEAP_ALLOC(cbAcl); 
        if (pNode->m_pbAcl)
            memcpy(pNode->m_pbAcl, pbAcl, cbAcl); 
        pNode->m_cbAcl = cbAcl;
        pNode->m_fAclInline = fAclInline;
    }
}


//
// GetReverseOperation : This function will return the reverse operation of the
//      current changelog operation.
//

DWORD
GetReverseOperation( 
    DWORD dwOpr
    )
{
    DWORD dwRestoreOpr = OPR_UNKNOWN;

    switch( dwOpr )
    {
    case OPR_FILE_DELETE: 
            dwRestoreOpr = OPR_FILE_ADD; 
            break;

    case OPR_FILE_ADD   :
            dwRestoreOpr = OPR_FILE_DELETE;
            break;

    case OPR_FILE_MODIFY:
            dwRestoreOpr = OPR_FILE_MODIFY;
            break;

    case OPR_SETATTRIB:
            dwRestoreOpr = OPR_SETATTRIB;
            break;

    case OPR_FILE_RENAME:
            dwRestoreOpr = OPR_FILE_RENAME;
            break;

    case OPR_DIR_RENAME:
            dwRestoreOpr = OPR_DIR_RENAME;
            break;

    case OPR_DIR_DELETE:
            dwRestoreOpr = OPR_DIR_CREATE;
            break;

    case OPR_DIR_CREATE:
            dwRestoreOpr = OPR_DIR_DELETE;
            break;

	case OPR_SETACL:
			dwRestoreOpr = OPR_SETACL;
			break;

    default:
            dwRestoreOpr = OPR_UNKNOWN;
            break;
    }

    return dwRestoreOpr;
}


//
// AllocateNode : allocates a list node 
//  

CNode * 
AllocateNode(
    LPWSTR  pPath1,
    LPWSTR  pPath2)
{
    CNode * pNode = NULL;
    BOOL    fRet = FALSE;
    
    if (! pPath1) 
    {
        fRet = TRUE;   // BUGBUG - is this a valid case?
        goto Exit;
    }

    pNode = (CNode *) HEAP_ALLOC( sizeof(CNode) );
    if (! pNode )
        goto Exit;    

    // all pointers set to NULL

    if ( pPath1 )
        STRCOPY(pNode->m_pPath1, pPath1);

    if ( pPath2 )
        STRCOPY(pNode->m_pPath2, pPath2);
        
    pNode->m_dwOperation = OPR_UNKNOWN;
    pNode->m_dwAttributes = 0xFFFFFFFF;
    pNode->m_pPrev = NULL;
    pNode->m_pNext = NULL;

    fRet = TRUE;

Exit:
    if (! fRet)
    {
        // something failed, so cleanup

        FreeNode(pNode);
        pNode = NULL;
    }

    return pNode;
}


//
// FreeNode : This function frees a list node
//

VOID
FreeNode(
    CNode * pNode
    )
{
    if ( pNode )
    {
        HEAP_FREE(pNode->m_pPath1);
        HEAP_FREE(pNode->m_pPath2);
        HEAP_FREE(pNode->m_pszTemp);
        HEAP_FREE(pNode->m_pbAcl);
        HEAP_FREE(pNode);
    }
}
	 

//
// Looks at an existing node and the new operation coming and decides
// if they can be merged or not.
//

BOOL
CanMerge(
    DWORD dwExistingOpr,
    DWORD dwNewOpr,
    DWORD dwFlags
    )
{
    BOOL fRet = FALSE;

    //
    // Don't optimize directory renames
    //

    if ( OPR_DIR_RENAME == dwExistingOpr ||
         OPR_DIR_RENAME == dwNewOpr )
        goto Exit;

    //
    // Don't optimize for rename if the node we find is a delete node
    // and the current opr is rename. In such cases since rename is
    // dependent on deletion to succeed.
    // Example : A -> B , Create A should generate Delete A, B -> A
    //

    if ( IsRename(dwNewOpr) &&                      
         ( OPR_DIR_DELETE == dwExistingOpr || OPR_FILE_DELETE == dwExistingOpr )
       )
        goto Exit;

    //
    // Also Del A, A->B should not merge this can happen if the file is
    // getting renamed out of the directory and back.
    //

    if ( IsRename(dwExistingOpr) &&                      
         ( OPR_DIR_DELETE == dwNewOpr || 
           OPR_DIR_CREATE == dwNewOpr ||
           OPR_FILE_DELETE == dwNewOpr )
       )
        goto Exit;


    if ( IsRename(dwNewOpr) &&                      
        ( OPR_DIR_DELETE == dwExistingOpr || 
          OPR_DIR_CREATE == dwExistingOpr )
       )
        goto Exit;

    //
    // Dir + File operations don't merge
    //

    if ( ( OPR_FILE_DELETE == dwExistingOpr ||
           OPR_FILE_MODIFY == dwExistingOpr ||
           OPR_FILE_ADD    == dwExistingOpr ) &&
         ( OPR_DIR_CREATE  == dwNewOpr ||
           OPR_DIR_DELETE  == dwNewOpr )
       )
        goto Exit;

         
    if ( ( OPR_FILE_DELETE == dwNewOpr ||
           OPR_FILE_ADD    == dwNewOpr ||
           OPR_FILE_MODIFY == dwNewOpr ) &&
         ( OPR_DIR_CREATE  == dwExistingOpr ||
           OPR_DIR_DELETE  == dwExistingOpr )
       )
        goto Exit;


    // can merge

    fRet = TRUE;

Exit:
    return fRet;
}


//
// CRestoreList implementation.
//

CRestoreList::CRestoreList()
{
    m_pListHead = m_pListTail = NULL;
}


CRestoreList::~CRestoreList()
{
    //
    // Destroy the list
    //

    CNode * pNodeNext = m_pListHead;

    CNode * pNode = NULL;
    while( pNodeNext )
    {
        pNode = pNodeNext;
        pNodeNext = pNodeNext->m_pNext;
        FreeNode( pNode );
    }
}


//
// AddNode : Alocates and Adds a tree node to the restore tree.
//

CNode *
CRestoreList::AppendNode( 
    LPWSTR        pPath1,
    LPWSTR        pPath2)
{
    CNode *      pNode = NULL;

    if ( pPath1 )

    {
        pNode = AllocateNode( pPath1, pPath2 );

        if ( !pNode )
        {
            goto Exit;
        }

        if( m_pListHead )
        {
            CNode * pPrevNode  = m_pListTail;            
            pPrevNode->m_pNext = pNode;
            pNode->m_pPrev     = pPrevNode;        
            pNode->m_pNext     = NULL;        
            m_pListTail = pNode;
        }
        else
        {
            m_pListHead = pNode;
            m_pListTail = pNode;
            pNode->m_pPrev = NULL;
            pNode->m_pNext = NULL;
        }
    }
         
Exit:
    return pNode;
}

//
// RemoveNode: Removes a node from the list
//

CNode *
CRestoreList::RemoveNode(
    CNode * pNode 
    )
{
    if ( pNode )
    {
        CNode * pPrevNode = pNode->m_pPrev;
        CNode * pNextNode = pNode->m_pNext;

        if (pPrevNode)
        {
            pPrevNode->m_pNext = pNode->m_pNext;    
        }

        if (pNextNode)
        {
            pNextNode->m_pPrev = pNode->m_pPrev;    
        }

        if ( pNode == m_pListHead )
        {
            m_pListHead = pNextNode;
        }
        
        if ( pNode == m_pListTail )
        {
            m_pListTail = pPrevNode;
        }

        pNode->m_pPrev = NULL;
        pNode->m_pNext = NULL;
    }


    return pNode;
}


//
// GetLastNode : finds the most recent candidate to merge
//
CNode * 
CRestoreList::GetLastNode(
    LPWSTR pPath1,
    LPWSTR pPath2,
    BOOL   fFailOnPrefixMatch
    )
{
    CNode * pNode = NULL;

    pNode = m_pListTail;

    while( pNode )
    {
        //
        // If the node has invalid operation skip it.
        //

        if ( OPR_UNKNOWN == pNode->m_dwOperation )
        {
            pNode = pNode->m_pPrev;
            continue;
        }

        //
        // If node matches, return it
        //

        if (0 == lstrcmpi(pPath1, pNode->m_pPath1))
            goto Exit; 

        //
        // Check for a dependent rename operation, if found we should not
        // merge beyond it.
        //

        if (  pPath1 && 
              IsRename(pNode->m_dwOperation) &&
              0 == lstrcmpi(pPath1, pNode->m_pPath2) )
        {
            pNode = NULL;
            goto Exit; 
        }

        //
        // Check for swap conditions, if so don't do any optimization.
        //

        if (  pPath2 && 
              IsRename(pNode->m_dwOperation) &&
              0 == lstrcmpi(pPath2, pNode->m_pPath2) )
        {
            pNode = NULL;
            goto Exit; 
        }

        //
        // Check if the entire  path matches  as a  prefix, in such a 
        // case we should fail search because an operation under that
        // directory is found.
        //

        if ( fFailOnPrefixMatch )
        {
            //
            // Check if entire path matches a prefix that means this
            // directory has other operations so don't merge.
            //

            if (StrStrI(pNode->m_pPath1, pPath1))
            {
                pNode = NULL;
                goto Exit; 
            }

            if ( IsRename(pNode->m_dwOperation) &&
                 StrStrI(pNode->m_pPath2, pPath1))
            {
                pNode = NULL;
                goto Exit; 
            }

            //
            // Check if prefix of the path matches with the full path in
            // nodelist, means we are moving across directory's lifespan.
            // ToDo: Only check for directory life operations
            //

            if ( IsRename(pNode->m_dwOperation) || 
				 OPR_DIR_DELETE == pNode->m_dwOperation ||
                 OPR_DIR_CREATE == pNode->m_dwOperation )
            {
                if ( StrStrI(pPath1, pNode->m_pPath1) )
                {
                    pNode = NULL;
                    goto Exit;
                }
                    
                if ( IsRename(pNode->m_dwOperation) &&
                     StrStrI(pPath1, pNode->m_pPath2) )
                {
                    pNode = NULL;
                    goto Exit; 
                }
    
                if ( pPath2 )
                {
                    if ( StrStrI(pPath2, pNode->m_pPath1) )
                    {
                        pNode = NULL;
                        goto Exit;
                    }
                    
                    if ( IsRename(pNode->m_dwOperation) &&
                         StrStrI(pPath2, pNode->m_pPath2) )
                    {
                        pNode = NULL;
                        goto Exit; 
                    }
                }
            }
        }

        pNode = pNode->m_pPrev;
    }

Exit:
    
    // 
    // We have found a potential merge candidate, now check if this is
    // a rename node and dest prefix has any operations on it.
    //

    if ( pNode && IsRename(pNode->m_dwOperation))
    {
        CNode * pTmpNode = m_pListTail;

        while( pTmpNode && pTmpNode != pNode )
        {
            if ( IsRename(pTmpNode->m_dwOperation) || 
                 OPR_DIR_DELETE == pTmpNode->m_dwOperation ||
                 OPR_DIR_CREATE == pTmpNode->m_dwOperation )
            {
                if ( StrStrI(pNode->m_pPath2, pTmpNode->m_pPath1) )
                {
                    pNode = NULL;
                    break;
                }
                    
                if  ( IsRename(pTmpNode->m_dwOperation) &&
                      StrStrI(pNode->m_pPath2, pTmpNode->m_pPath2) )
                {
                    pNode = NULL;
                    break;
                }
            }
        
            pTmpNode = pTmpNode->m_pPrev;
        }
    }
   
    return pNode;
}

//
// CopyNode : Copies node information, destination opr, copy data, etc.
//

BOOL
CRestoreList::CopyNode(
    CNode  * pSrcNode,
    CNode  * pDesNode,
    BOOL   fReplacePPath2
    )
{
    BOOL fRet = FALSE;

    if (pSrcNode && pDesNode)
    {
        pSrcNode->m_dwOperation  = pDesNode->m_dwOperation ;
        pSrcNode->m_dwAttributes = pDesNode->m_dwAttributes;

        STRCOPY(pSrcNode->m_pszTemp, pDesNode->m_pszTemp);
        CopyAcl(pSrcNode, pDesNode->m_pbAcl, pDesNode->m_cbAcl, pDesNode->m_fAclInline);

        if ( IsRename(pDesNode->m_dwOperation) && fReplacePPath2 )
        {
            HEAP_FREE( pSrcNode->m_pPath2 );
            pSrcNode->m_pPath2 = pDesNode->m_pPath2;
            pDesNode->m_pPath2 = NULL;
        }
        
        fRet = TRUE;        
    }

    return fRet;
}

//
// CreateRestoreNode : Creates appropriate restore node 
//

CRestoreList::CreateRestoreNode(
    CNode       * pNode,
    DWORD         dwOpr,
    DWORD         dwAttr,
    DWORD         dwFlags,
    LPWSTR        pTmpFile,
    LPWSTR        pPath1,
    LPWSTR        pPath2,
    BYTE*         pbAcl,
    DWORD         cbAcl,
    BOOL          fAclInline)
{
    BOOL fRet = FALSE;

    if (pNode)
    {
        fRet = TRUE;
        DWORD  dwRestoreOpr = GetReverseOperation( dwOpr );

        //
        // If Source / Dest paths are same then remove this just
        // added node.
        //

        if ( IsRename(dwRestoreOpr) &&
             0 == lstrcmpi(pNode->m_pPath1, 
                         pNode->m_pPath2) )
        {
            RemoveNode( pNode );
            FreeNode( pNode );
            goto Exit;
        }

        //
        // Rename optimizations should not be done for directories.
        //

        if ( OPR_FILE_RENAME == dwRestoreOpr )  
        {
            //
            // Check if the des node already exists in the tree, if so
            // copy all the data from that node and delete it. Current
            // node effectively represents that node. 
            //

            DWORD dwCurNodeOpr  = pNode->m_dwOperation;
            CNode *pNodeDes = GetLastNode( pPath2, pPath1, TRUE ); 

            if (pNodeDes &&
                OPR_UNKNOWN != pNodeDes->m_dwOperation)
            {
                //
                // Check for Cycle if so remove the current node also
                //
              
                if ( OPR_FILE_RENAME == pNodeDes->m_dwOperation  && 
                     !lstrcmpi (pNode->m_pPath1, 
                                pNodeDes->m_pPath2) )
                {
                    //
                    // The existing node may be a hybrid one so preserve the
                    // hybrid operations cancel only rename
                    //

                    if (! pNodeDes->m_pszTemp &&
                        pNodeDes->m_dwAttributes == 0xFFFFFFFF &&
                        pNodeDes->m_pbAcl == NULL)    
                    {
                        //
                        // Not a hybrid node - remove it.
                        //

                        RemoveNode( pNodeDes );
                        FreeNode( pNodeDes );
                    }
                    else
                    {
                        //
                        // Hybrid Node so change the node to the other
                        // operations only.
                        //

                        HEAP_FREE( pNodeDes->m_pPath1 );
                        pNodeDes->m_pPath1 = pNodeDes->m_pPath2;
                        pNodeDes->m_pPath2 = NULL;                                              
                        pNodeDes->m_dwOperation = OPR_SETATTRIB;

                        if (pNodeDes->m_pbAcl)
                        {
                            pNodeDes->m_dwOperation = OPR_SETACL;
                        }

                        if (pNodeDes->m_pszTemp)
                        {
                            pNodeDes->m_dwOperation = OPR_FILE_MODIFY;
                        }
                    }
                   
                    //
                    // Remove the just add node as the operation cancels
                    // returning false will have that effect

                    fRet = FALSE;

                    goto Exit;
                }

                //
                // Remove the matching node from the list
                //

                RemoveNode( pNodeDes );

                //
                // Merge the matching node into the current rename node
                //

                CopyNode( pNode, pNodeDes, TRUE );

                //
                // Since all the information for modify/attrib/acl is
                // copied over, change the opr to rename.
                //

                if (pNodeDes->m_dwOperation == OPR_SETATTRIB ||
                    pNodeDes->m_dwOperation == OPR_SETACL ||
                    pNodeDes->m_dwOperation == OPR_FILE_MODIFY)
                {
                    pNode->m_dwOperation = dwRestoreOpr;                    
                    STRCOPY(pNode->m_pPath2, pPath2);
                }

                //
                // If current opr on the node was delete and the newly
                // copied operation is create we need to merge these and
                // and change the operation to modify
                //
                // BUGBUG - will this code ever be executed?
                // dwCurNodeOpr always seems to be OPR_UNKNOWN

                if ( OPR_FILE_ADD    == pNodeDes->m_dwOperation &&
                     OPR_FILE_DELETE == dwCurNodeOpr )
                {
                    pNode->m_dwOperation = OPR_FILE_MODIFY;
                }
                
                if ( OPR_DIR_CREATE == pNodeDes->m_dwOperation &&
                     OPR_DIR_DELETE == dwCurNodeOpr )
                {
                    pNode->m_dwOperation = OPR_SETATTRIB;
                }
                
                //
                // If the operation is changed from a rename then pPath2 should
                // not exist
                //
                
                if ( OPR_FILE_RENAME != pNode->m_dwOperation ) 
                {
                    if ( pNode->m_pPath2 )
                    {
                        HEAP_FREE(pNode->m_pPath2);
                        pNode->m_pPath2 = NULL ;
                    }
                }
                
                FreeNode( pNodeDes );
                goto Exit;
            }            
        }

        //
        // Copy the necessary information into this node.
        //

        pNode->m_dwOperation  = dwRestoreOpr;
        pNode->m_dwAttributes = dwAttr;
        STRCOPY(pNode->m_pszTemp, pTmpFile);
        CopyAcl(pNode, pbAcl, cbAcl, fAclInline);
    }

Exit:
    return fRet;
}


//
// MergeRestoreNode : Merge the new information into the current retore node
//

BOOL
CRestoreList::MergeRestoreNode(
    CNode       * pNode,
    DWORD         dwOpr,
    DWORD         dwAttr,
    DWORD         dwFlags,
    LPWSTR        pTmpFile,
    LPWSTR        pPath1,
    LPWSTR        pPath2,
    BYTE*         pbAcl,
    DWORD         cbAcl,
    BOOL          fAclInline)
{
    BOOL fRet = FALSE;

    if (pNode)
    {
        DWORD dwRestoreOpr = GetReverseOperation( dwOpr );

        // note that dwOpr cannot be a rename operation,
        // because we handle that separately in CreateRestoreNode

        ASSERT( ! IsRename(dwOpr) );

        switch( dwOpr )
        {
        case OPR_FILE_ADD :
            {
                //
                // If current opr is add and the node already encountered a
                // delete opr then remove this node because this is a no-op
                //

                if ( OPR_FILE_ADD == pNode->m_dwOperation )
                {
                    RemoveNode( pNode );
                    FreeNode  ( pNode );
                    goto Exit;
                }

                
                if ( IsRename(pNode->m_dwOperation) )
                {
                    // 
                    // Change the original node to a delete operation, to
                    // retain proper order.
                    //

                    pNode->m_dwOperation  = OPR_FILE_DELETE;

                    //
                    // Delete operation should be generated on PPath2
                    //

                    if (pNode->m_pPath1)
                    {
                         HEAP_FREE( pNode->m_pPath1);
                         pNode->m_pPath1 = NULL;
                    }

                    if (pNode->m_pPath2)
                    {
                         pNode->m_pPath1 = pNode->m_pPath2;
                         pNode->m_pPath2 = NULL;
                    }

                    goto Exit;
                }

                break;
            }
        case OPR_FILE_DELETE :
            {
                //
                // Delete followd by an add should result in modify
                //

                if (OPR_FILE_DELETE == pNode->m_dwOperation)
                {
                    pNode->m_dwOperation = OPR_FILE_MODIFY;                   
                    pNode->m_dwAttributes = dwAttr;
                    STRCOPY(pNode->m_pszTemp, pTmpFile); 
                    CopyAcl(pNode, pbAcl, cbAcl, fAclInline);
                    goto Exit;
                }

                break;
            }
        case OPR_FILE_MODIFY:
            {
                //
                // Copy the modified file copy location, don't change
                // the current restore operation.
                //

                if ( OPR_FILE_ADD == pNode->m_dwOperation ||
                     IsRename(pNode->m_dwOperation) )
                {
                    STRCOPY(pNode->m_pszTemp, pTmpFile); 
                    goto Exit;
                }
                break;
            }
        case OPR_SETATTRIB:
            {
                //
                // Don't change the current restore operation just set the attr.
                //

                if ( OPR_UNKNOWN != pNode->m_dwOperation )
                {
                    pNode->m_dwAttributes = dwAttr;
                    goto Exit;               
                }

                break;
            }
        case OPR_SETACL:
            {
                // setacl followed by any op
                // just copy the acl to the new op
            
                if (OPR_UNKNOWN != pNode->m_dwOperation)
                {
                    CopyAcl(pNode, pbAcl, cbAcl, fAclInline);
                    goto Exit;
                }

                break;
            }
        case OPR_DIR_DELETE :
            {
                //
                // if Dir delete followed by a dir create then this
                // operation should condense to set attrib + setacl

                if ( OPR_DIR_DELETE == pNode->m_dwOperation )
                {
                    //
                    // Need to change the oprn to set attrib if
                    // Attribute changed 
                    //

                    pNode->m_dwOperation  = OPR_SETATTRIB;
                    pNode->m_dwAttributes = dwAttr;
                    CopyAcl(pNode, pbAcl, cbAcl, fAclInline);
                    goto Exit;
                }
                
                break;
            }
        case OPR_DIR_CREATE :
            {
                if ( OPR_DIR_CREATE == pNode->m_dwOperation )
                {
                    RemoveNode( pNode );
                    FreeNode( pNode );
                    goto Exit;
                }
                
                if ( IsRename(pNode->m_dwOperation) )
                {
                    //
                    // Check if the existing node has some file operations
                    // afterwards then don't optimize
                    //

                    if ( GetLastNode( 
                             pNode->m_pPath1,
                             NULL,
                             TRUE) ) 
                    {
                        // 
                        // Change the last node to a delete operation, to
                        // retain proper order.
                        //

                        pNode->m_dwOperation  = OPR_DIR_DELETE;
    
                        //
                        // Delete operation should be generated on PPath2
                        //

                        if (pNode->m_pPath1)
                        {
                             HEAP_FREE( pNode->m_pPath1);
                             pNode->m_pPath1 = NULL;
                        }

                        if (pNode->m_pPath2)
                        {
                             pNode->m_pPath1 = pNode->m_pPath2;
                             pNode->m_pPath2 = NULL;
                        }
                    }
                    else
                    {
                        CNode * pNewNode = NULL;

                        //
                        // Create a new dir delete node
                        //

                        if (pNewNode = AppendNode(pPath1, pPath2) )
                        {
                             fRet = CreateRestoreNode( 
                                        pNewNode,
                                        dwOpr, 
                                        dwAttr, 
                                        dwFlags,
                                        pTmpFile, 
                                        pPath1,
                                        pPath2,
                                        pbAcl,
                                        cbAcl,
                                        fAclInline);
                        }
                    }

                    goto Exit;
                }
                break;
            }
        }

         pNode->m_dwOperation  = dwRestoreOpr;

        //
        // Change the node's attribute only if the new attrib exists
        //

        if (dwAttr != 0xFFFFFFFF) 
            pNode->m_dwAttributes = dwAttr;
    
        STRCOPY(pNode->m_pszTemp, pTmpFile);
        CopyAcl(pNode, pbAcl, cbAcl, fAclInline);
    }

Exit:

    return TRUE;
}


BOOL
CRestoreList::CheckIntegrity(    
    LPWSTR pszDrive,
    DWORD  dwOpr,
    DWORD  dwAttr,
    DWORD  dwFlags,
    LPWSTR pTmpFile,
    LPWSTR pPath1,
    LPWSTR pPath2,
    BYTE * pbAcl,
    DWORD  cbAcl,
    BOOL   fAclInline)
{
    BOOL    fRet = TRUE;
    WCHAR   szPath[MAX_PATH];
    
    // source name MUST be present
    
    if (! pPath1)
    {
        fRet = FALSE;
        goto done;
    }

    // if acl is present and it's not inline,
    // then temp file must exist

    if (pbAcl && ! fAclInline)
    {
        MakeRestorePath(szPath, pszDrive, (LPWSTR) pbAcl);    
        if (-1 == GetFileAttributes(szPath))
        {
            fRet = FALSE;
            goto done;
        }
    }
       
    
    switch (dwOpr)
    {
    case OPR_FILE_RENAME:
    case OPR_DIR_RENAME:
        // renames should have dest path and no temp file        
        if (! pPath2 || pTmpFile)
            fRet = FALSE;
        break;

    case OPR_FILE_MODIFY:
        // modify should not have dest path but must have temp file
        if (pPath2 || ! pTmpFile)
        {
            fRet = FALSE;
            break;
        }

        // and the temp file must exist inside the datastore        
        MakeRestorePath(szPath, pszDrive, pTmpFile);

        if (-1 == GetFileAttributes(szPath))
        {
            fRet = FALSE;
            break;
        }
            
        break;
        
    case OPR_SETACL:
        // acl operation should have acl (either inline or not)
        if (! pbAcl)
        {
            fRet = FALSE;
            break;
        }

    default:
        break;
   }


done:
    return fRet;   
}


    
// AddMergeElement : Adds or merge the current element as appropriate
//

BOOL
CRestoreList::AddMergeElement(
    LPWSTR pszDrive,
    DWORD  dwOpr,
    DWORD  dwAttr,
    DWORD  dwFlags,
    LPWSTR pTmpFile,
    LPWSTR pPath1,
    LPWSTR pPath2,
    BYTE * pbAcl,
    DWORD  cbAcl,
    BOOL   fAclInline)
{
    BOOL    fRet = FALSE;
    CNode * pNode = NULL;

    // check to see if the entry is consistent
    
    fRet = CheckIntegrity(pszDrive,
                          dwOpr,
                          dwAttr, 
                          dwFlags, 
                          pTmpFile, 
                          pPath1, 
                          pPath2, 
                          pbAcl, 
                          cbAcl, 
                          fAclInline);
    if (FALSE == fRet)
    {
        ASSERT(-1);
        goto Exit;
    }
        
    if ( pPath1 )
    {
         if ( 
              //
              // Merge for renames are handled inside the Create/Merge funcs
              //

              ! IsRename(dwOpr) &&

              //
              // Merge should only be allowed within directory life, check 
              // node paths to see if there are any directory life oprs.
              //

              ( pNode = GetLastNode( pPath1, pPath2, TRUE ) ) &&
              CanMerge( pNode->m_dwOperation , dwOpr, dwFlags ) 


            )
         {
              fRet = MergeRestoreNode( 
                         pNode,
                         dwOpr, 
                         dwAttr, 
                         dwFlags,
                         pTmpFile, 
                         pPath1,
                         pPath2,
                         pbAcl,
                         cbAcl,
                         fAclInline);

              if (!fRet)
                  goto Exit;

         }
         else
         {
             if (pNode = AppendNode(pPath1, pPath2) )
             {
                 fRet = CreateRestoreNode( 
                            pNode,
                            dwOpr, 
                            dwAttr, 
                            dwFlags,
                            pTmpFile, 
                            pPath1,
                            pPath2,
                            pbAcl,
                            cbAcl,
                            fAclInline);

                 if (!fRet)
                 { 
                     //
                     // We failed to create the node properly, free this node
                     //

                     RemoveNode( pNode );
                     FreeNode( pNode );

                     //
                     // We still want to continue
                     //

                     fRet = TRUE;

                     goto Exit;
                 }
            }
        }
    }

Exit:
    return fRet;
}


//
// GenerateRestoreMap : Walk the tree and generates the restore map.
//

BOOL
CRestoreList::GenerateRestoreMap (
    HANDLE hFile 
    )
{
    BOOL fRet = FALSE;

    if (hFile)
    {
        CNode * pNode = m_pListHead;

        while (pNode)
        {
            if (! GenerateOperation( pNode , hFile ))
                goto Exit;
            
            pNode = pNode->m_pNext;
        }

        fRet = TRUE;
    }

Exit:
    return fRet;
}

//
// GenerateRenameEntry : Callback to write out the renames
//

BOOL
CRestoreList::GenerateRenameEntry(
    CNode    * pNode ,
    HANDLE     hFile
    )
{
    BOOL fRet = FALSE;

    if( !pNode || ! IsRename(pNode->m_dwOperation) )
        goto Exit;

     //
     // Check if this rename is no-op , src/des are the same
     //

     if ( IsRename(pNode->m_dwOperation) &&
          lstrcmpi(pNode->m_pPath1, pNode->m_pPath2) == 0)
     {
         goto SkipMainNodeEntry;
     }

     // add rename operation

     fRet = AppendRestoreMapEntry( 
           hFile, 
           pNode->m_dwOperation,
           0xFFFFFFFF,
           NULL,
           pNode->m_pPath1,
           pNode->m_pPath2,
           NULL,
           0,
           0);

SkipMainNodeEntry:

     // add modify operation if temp file exists

     if ( pNode->m_pszTemp )
     {
         fRet = AppendRestoreMapEntry( 
                hFile, 
                OPR_FILE_MODIFY,
                0xFFFFFFFF,
                pNode->m_pszTemp,
                pNode->m_pPath1,
                NULL,
                NULL,
                0,
                0);
     }

     // add setattrib operation if attrib exists

     if ( pNode->m_dwAttributes != 0xFFFFFFFF &&
          pNode->m_dwAttributes != FILE_ATTRIBUTE_DIRECTORY )
     {
          fRet = AppendRestoreMapEntry( 
                 hFile,
                 OPR_SETATTRIB,
                 pNode->m_dwAttributes,
                 NULL,
                 pNode->m_pPath1,
                 NULL,
                 NULL,
                 0,
                 0);
     }

     // add setacl operation if acl exists

     if ( pNode->m_pbAcl != NULL && 
          pNode->m_cbAcl != 0)
     {
          fRet = AppendRestoreMapEntry( 
                 hFile,
                 OPR_SETACL,
                 0xFFFFFFFF,
                 NULL,
                 pNode->m_pPath1,
                 NULL,
                 pNode->m_pbAcl,
                 pNode->m_cbAcl,
                 pNode->m_fAclInline);
     }
         

Exit:
    return fRet;
}


BOOL
CRestoreList::GenerateOperation(
    CNode    * pNode ,
    HANDLE     hFile
    )
{
    BOOL fRet = FALSE;

    BYTE bData[4096];

    RestoreMapEntry * pResEntry = (RestoreMapEntry *)bData;

    if( !pNode || OPR_UNKNOWN == pNode->m_dwOperation)
        goto Exit;

    if (IsRename(pNode->m_dwOperation) )
    {
         fRet = GenerateRenameEntry( pNode, hFile );
         goto Exit;
    }

    //
    // Generate operations for Add/Modify/SetAttrib
    //
    
    // ensure that each persisted entry contains only necessary data
    // e.g. a setattrib entry will not contain a temp filename, or acl

    fRet = AppendRestoreMapEntry(
               hFile, 
               pNode->m_dwOperation,
               (pNode->m_dwOperation == OPR_SETATTRIB) ? pNode->m_dwAttributes : 0xFFFFFFFF,
               (pNode->m_dwOperation == OPR_FILE_MODIFY || 
                pNode->m_dwOperation == OPR_FILE_ADD) ? pNode->m_pszTemp : NULL,
               pNode->m_pPath1,
               NULL,      // pPath2 should matter only for renames, which are handled separately
               (pNode->m_dwOperation == OPR_SETACL) ? pNode->m_pbAcl : NULL,
               (pNode->m_dwOperation == OPR_SETACL) ? pNode->m_cbAcl : 0,
               (pNode->m_dwOperation == OPR_SETACL) ? pNode->m_fAclInline : 0);


    //
    // Generate an explicit set attrib operation 
    // entries except set attrib itself and delete.
    //

    if ( OPR_SETATTRIB   != pNode->m_dwOperation &&
         OPR_FILE_DELETE != pNode->m_dwOperation &&
         OPR_DIR_DELETE  != pNode->m_dwOperation &&
         pNode->m_dwAttributes != 0xFFFFFFFF &&
         pNode->m_dwAttributes != FILE_ATTRIBUTE_DIRECTORY )
    {
         fRet = AppendRestoreMapEntry(
                    hFile,
                    OPR_SETATTRIB,
                    pNode->m_dwAttributes,
                    NULL,
                    pNode->m_pPath1,
                    NULL,
                    NULL,
                    0,
                    0);
    }

    //
    // Generate an explicit set acl if needed
    //

    if ( pNode->m_pbAcl != NULL && 
         pNode->m_cbAcl != 0 &&
         OPR_SETACL   != pNode->m_dwOperation &&
         OPR_FILE_DELETE != pNode->m_dwOperation &&
         OPR_DIR_DELETE  != pNode->m_dwOperation)
    {
         fRet = AppendRestoreMapEntry(
                    hFile,
                    OPR_SETACL,
                    0xFFFFFFFF,
                    NULL,
                    pNode->m_pPath1,
                    NULL,
                    pNode->m_pbAcl,
                    pNode->m_cbAcl,
                    pNode->m_fAclInline);
    }

Exit:
    return fRet;
}