/*++

   Copyright    (c)    1995-1996    Microsoft Corporation

   Module  Name :

       dirmon.cpp

   Abstract:
       This module includes definitions of functions and variables
        for CDirMonitor and CDirMonitorEntry object

   Author:

       Charles Grant       ( cgrant   )     April-1997

   Revision History:

        Changed to abstract classes to share code between core IIS and ASP

--*/


/************************************************************
 *     Include Headers
 ************************************************************/

#include "isatq.hxx"
#include "malloc.h"
#include "except.h"

#define IATQ_DLL_IMPLEMENTATION
#define IATQ_IMPLEMENTATION_EXPORT

#include "dirmon.h"


//
// CDirMonitorEntry
//

#define DEFAULT_BUFFER_SIZE 512

CDirMonitorEntry::CDirMonitorEntry() :
                    m_cDirRefCount(0),
                    m_cIORefCount(0),
                    m_hDir(INVALID_HANDLE_VALUE),
                    m_pAtqCtxt(NULL),
                    m_dwNotificationFlags(0),
                    m_pszPath(NULL),
                    m_cPathLength(0),
                    m_pDirMonitor(NULL),
                    m_cBufferSize(0),
                    m_pbBuffer(NULL),
                    m_fInCleanup(FALSE),
                    m_fWatchSubdirectories(FALSE)
/*++

Routine Description:

    CDirMonitorEntry constructor

Arguments:

    None

Return Value:

    Nothing

--*/
{
}


CDirMonitorEntry::~CDirMonitorEntry(
    VOID
    )
/*++

Routine Description:

    CDirMonitorEntry destructor

Arguments:

    None

Return Value:

    Nothing

--*/
{

    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitorEntry] Destructor\n"));
    }

    // We should only be destroyed when
    // our ref counts have gone to 0

    DBG_ASSERT(m_cDirRefCount == 0);
    DBG_ASSERT(m_cIORefCount == 0);

    //
    // We really ought to have closed the handle by now
    //
    if (m_hDir != INVALID_HANDLE_VALUE) {
        DBGPRINTF(( DBG_CONTEXT, "~CDirMonitorEntry: open handle %p : %p\n",
                    m_hDir, m_pAtqCtxt ));

        m_hDir = INVALID_HANDLE_VALUE;
        AtqCloseFileHandle(m_pAtqCtxt);
    }

    if (m_pDirMonitor != NULL)
    {
        m_pDirMonitor->RemoveEntry(this);
        m_pDirMonitor = NULL;
    }

    m_cPathLength = 0;

    if ( m_pszPath != NULL )
    {
        free( m_pszPath );
        m_pszPath = NULL;
    }

    if (m_pAtqCtxt)
    {
        AtqFreeContext(m_pAtqCtxt, FALSE);
        m_pAtqCtxt = NULL;
    }

    if (m_pbBuffer != NULL)
    {
        free(m_pbBuffer);
        m_cBufferSize = 0;
    }
}

BOOL
CDirMonitorEntry::Init(
    DWORD cBufferSize = DEFAULT_BUFFER_SIZE
)
/*++

Routine Description:

    Initialize the dir montior entry.

Arguments:

    cBufferSize  - Initial size of buffer used to store change notifications

Return Value:

    TRUE if success, otherwise FALSE

--*/
{
        // Don't allow a 0 length buffer
        if (cBufferSize == 0)
        {
                return FALSE;
        }

    DBG_ASSERT( m_pbBuffer == NULL );

        m_pbBuffer = (BYTE *) malloc(cBufferSize);

        if (m_pbBuffer != NULL)
        {
                m_cBufferSize = cBufferSize;
                return TRUE;
        }
        else
        {
                // Unable to allocate buffer
        return FALSE;
    }
}

BOOL
CDirMonitorEntry::RequestNotification(
    VOID
)
/*++

Routine Description:

    Request ATQ to monitor directory changes for the directory handle
    associated with this entry

Arguments:

    None

Return Value:

    TRUE if success, otherwise FALSE

--*/
{
    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitorEntry] Request change notification\n"));
    }

    BOOL fResult = FALSE;

    DBG_ASSERT(m_pDirMonitor);

    // Reset the overlapped io structure

    memset(&m_ovr, 0, sizeof(m_ovr));

    // Increase the ref count in advance

    IOAddRef();

    // Request notification of directory changes

    fResult = AtqReadDirChanges( m_pAtqCtxt,              // Atq context handle
                            m_pbBuffer,                // Buffer for change notifications
                            m_cBufferSize,          // Size of buffer
                            m_fWatchSubdirectories,  // Monitor subdirectories?
                            m_dwNotificationFlags,   // Which changes should we be notified of
                            &m_ovr );                // Overlapped IO structure

    if (!fResult)
    {
        // ReadDirChanges failed so
        // release the ref count we did in advance
        // Might cause IO ref count to go to 0

        IORelease();
    }

    return fResult;

}

BOOL
CDirMonitorEntry::Cleanup(
    VOID
    )
/*++

Routine Description:

    Cleans up resource and determines if the caller need to delete
    the Directory Monitor Entry instance.

Arguments:

    None

Return Value:

    TRUE if the caller is responsible for deleting the object
    This will be the case if there are no pending Asynch IO requests

--*/
{
    DBG_ASSERT(m_cDirRefCount == 0);

    BOOL fDeleteNeeded = FALSE;
    BOOL fHandleClosed = FALSE;

    BOOL fInCleanup = (BOOL) InterlockedExchange((long *) &m_fInCleanup, TRUE);

    if (!fInCleanup)
    {
        // Get the IO ref count BEFORE we close the handle

        DWORD cIORefCount = m_cIORefCount;

        if (m_hDir != INVALID_HANDLE_VALUE)
        {
            // If we have a pending AtqReadDirectoryChanges,
            // closing the directory handle will cause a call back from ATQ.
            // The call back should relase the final refcount on the object
            // which should result in its deletion

            m_hDir = INVALID_HANDLE_VALUE;
            fHandleClosed = AtqCloseFileHandle( m_pAtqCtxt );
        }

        // If there were no pending Asynch IO operations or if we failed
        // to close the handle, then the caller will be responsible for
        // deleting this object.

        if (cIORefCount == 0 || fHandleClosed == FALSE)
        {
            fDeleteNeeded = TRUE;
        }
    }

    return fDeleteNeeded;
}

BOOL
CDirMonitorEntry::ResetDirectoryHandle(
    VOID
    )
/*++

Routine Description:

    Opens a new directory handle and ATQ context for the path,
    and closes the old ones. We want to be able to do this so we
    can change the size of the buffer passed in ReadDirectoryChangesW.
    If we are unable to get a new handle or a new ATQ context, we leave
    the existing ones in place.

Arguments:

    None

Return Value:

    TRUE if the handles were succesfully reopened
    FALSE otherwise

--*/
{
        // We'd better have a directory path available to try this
        
        if (m_pszPath == NULL)
        {
                return FALSE;
        }
        
    // Get a new handle to the directory

    HANDLE hDir = CreateFile(
                           m_pszPath,
                           FILE_LIST_DIRECTORY,
                                FILE_SHARE_READ |
                                FILE_SHARE_WRITE |
                                FILE_SHARE_DELETE,
                           NULL,
                           OPEN_EXISTING,
                           FILE_FLAG_BACKUP_SEMANTICS |
                                FILE_FLAG_OVERLAPPED,
                           NULL );

    if ( hDir == INVALID_HANDLE_VALUE )
    {
        // We couldn't open another handle on the directory,
        // leave the current handle and ATQ context alone

        return FALSE;
    }

    // Get a new ATQ context for our new handle

    PATQ_CONTEXT pAtqCtxt = NULL;
    if ( !AtqAddAsyncHandle(&pAtqCtxt,
                                NULL,
                                (LPVOID) this,
                                (ATQ_COMPLETION) CDirMonitor::DirMonitorCompletionFunction,
                                INFINITE,
                                hDir ) )
    {
        // We couldn't get a new ATQ context. Close our new handle.
        // We leave the objects current handle and ATQ context alone
        CloseHandle(hDir);
        return FALSE;
    }

    // We have the new handle and ATQ context so we close
    // and replace the old ones.

    AtqCloseFileHandle(m_pAtqCtxt);
        AtqFreeContext(m_pAtqCtxt, FALSE);
        m_pAtqCtxt = pAtqCtxt;
        m_hDir = hDir;

        return TRUE;
}

BOOL
CDirMonitorEntry::SetBufferSize(
    DWORD cBufferSize
    )
/*++

Routine Description:

    Sets the size of the buffer used for storing change notification records

Arguments:

    cBufferSize         new size for the buffer.

Return Value:

    TRUE        if the size of the buffer was succesfully set
    FALSE       otherwise

Note

        When a call to ReadDirectoryChangesW is made, the size of the buffer is set in
        the data associated with the directory handle and is not changed on subsequent
        calls to ReadDirectoryChangesW. To make use of the new buffer size the directory
        handle must be closed and a new handle opened (see ResetDirectoryHandle())
        
--*/
{
        // We should never be called if the buffer doesn't already exist
        
        ASSERT(m_pbBuffer);
        
        // Don't allow the buffer to be set to 0
        
        if (cBufferSize == 0)
        {
                return FALSE;
        }

        VOID *pbBuffer = realloc(m_pbBuffer, cBufferSize);

        if (pbBuffer == NULL)
        {
                // Re-allocation failed, stuck with the same size buffer
                
                return FALSE;
        }
        else
        {
                // Re-allocation succeded, update the member variables
                
                m_pbBuffer = (BYTE *) pbBuffer;
                m_cBufferSize = cBufferSize;
                return TRUE;
        }
}

//
// CDirMonitor
//

CDirMonitor::CDirMonitor()
    : CTypedHashTable<CDirMonitor, CDirMonitorEntry, const char*>("DirMon")
/*++

Routine Description:

    CDirMonitor constructor

Arguments:

    None

Return Value:

    Nothing

--*/
{
    INITIALIZE_CRITICAL_SECTION( &m_csLock );
    INITIALIZE_CRITICAL_SECTION( &m_csSerialComplLock );
    m_cRefs = 1;
}


CDirMonitor::~CDirMonitor()
/*++

Routine Description:

    CDirMonitor destructor

Arguments:

    None

Return Value:

    Nothing

--*/
{
    DeleteCriticalSection(&m_csLock);
    DeleteCriticalSection(&m_csSerialComplLock);
}

BOOL
CDirMonitor::Monitor(
    CDirMonitorEntry *pDME,
    LPCSTR pszDirectory,
    BOOL fWatchSubDirectories,
    DWORD dwNotificationFlags
    )
/*++

Routine Description:

    Create a monitor entry for the specified path

Arguments:

    pszDirectory - directory to monitor
    pCtxt - Context of path is being monitored
    pszDirectory - name of directory to monitor
    fWatchSubDirectories - whether to get notifications for subdirectories
    dwNotificationFlags - which activities to be notified of

Return Value:

    TRUE if success, otherwise FALSE

Remarks:

    Caller should have a lock on the CDirMonitor
    Not compatible with WIN95

--*/
{
    LIST_ENTRY  *pEntry;
    HANDLE      hDirectoryFile = INVALID_HANDLE_VALUE;
    BOOL        fRet = TRUE;
    DWORD       dwDirLength = 0;

    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitor] Monitoring new CDirMonitorEntry\n"));
    }

    // Must have a directory monitor entry and a string
    // containing the directory path

    if (!pDME || !pszDirectory)\
    {
        SetLastError(ERROR_INVALID_PARAMETER);
        return FALSE;
    }

    // Make copy of pszDirectory for the entry to hang on to


    pDME->m_cPathLength = strlen(pszDirectory);
    if ( !(pDME->m_pszPath = (LPSTR)malloc( pDME->m_cPathLength + 1 )) )
    {
        pDME->m_cPathLength = 0;
        return FALSE;
    }
    memcpy( pDME->m_pszPath, pszDirectory, pDME->m_cPathLength + 1 );

    pDME->Init();

    // Open the directory handle

    hDirectoryFile = CreateFile(
                           pszDirectory,
                           FILE_LIST_DIRECTORY,
                                FILE_SHARE_READ |
                                FILE_SHARE_WRITE |
                                FILE_SHARE_DELETE,
                           NULL,
                           OPEN_EXISTING,
                           FILE_FLAG_BACKUP_SEMANTICS |
                                FILE_FLAG_OVERLAPPED,
                           NULL );

    if ( hDirectoryFile == INVALID_HANDLE_VALUE )
    {
        // Cleanup
        free(pDME->m_pszPath);
        pDME->m_pszPath = NULL;
        pDME->m_cPathLength = 0;
        return FALSE;
    }
    else
    {
        // Store the handle so we can close it on cleanup

        pDME->m_hDir = hDirectoryFile;

        // Set the flags for the type of notifications we want
        // and if we should watch subdirectories or just the root

        pDME->m_dwNotificationFlags = dwNotificationFlags;
        pDME->m_fWatchSubdirectories = fWatchSubDirectories;

        // Get an ATQ context for this handle
        // and register our completion call back function

        if ( AtqAddAsyncHandle( &pDME->m_pAtqCtxt,
                                NULL,
                                (LPVOID) pDME,
                                (ATQ_COMPLETION) DirMonitorCompletionFunction,
                                INFINITE,
                                hDirectoryFile ) )
        {
            // Insert this entry into the list of active entries

            if (InsertEntry(pDME) == LK_SUCCESS)
            {

                // Ask for notification if this directory has changes

                if (!pDME->RequestNotification())
                {
                        // Couldn't register for change notification
                        // Clean up resources
                    RemoveEntry(pDME);
                        pDME->m_hDir = INVALID_HANDLE_VALUE;
                        AtqCloseFileHandle(pDME->m_pAtqCtxt);
                        free(pDME->m_pszPath);
                        pDME->m_pszPath = NULL;
                        pDME->m_cPathLength = 0;
                        return FALSE;
                }
            }
        }
        else
        {
           
            // Failed to add handle to ATQ, clean up

            CloseHandle(hDirectoryFile);
            pDME->m_hDir = INVALID_HANDLE_VALUE;
            free(pDME->m_pszPath);
            pDME->m_pszPath = NULL;
            pDME->m_cPathLength = 0;
            return FALSE;
        }

    }

    return TRUE;
}

VOID
CDirMonitor::DirMonitorCompletionFunction(
    PVOID pCtxt,
    DWORD dwBytesWritten,
    DWORD dwCompletionStatus,
    OVERLAPPED *pOvr
    )
/*++

Routine Description:

Static member function called by ATQ to signal directory changes

Arguments:

    pCtxt - CDirMonitorEntry*
    dwBytesWritten - # bytes returned by ReadDirectoryChanges
    dwCompletionStatus - status of request to ReadDirectoryChanges
    pOvr - OVERLAPPED as specified in call to ReadDirectoryChanges

Return Value:

    Nothing

--*/
{
    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitor] Notification call-back begining. Status %d\n", dwCompletionStatus));
    }

    CDirMonitorEntry*  pDirMonitorEntry = reinterpret_cast<CDirMonitorEntry*>(pCtxt);

    DBG_ASSERT(pDirMonitorEntry);

    // Safety add ref, this should guarentee that the DME is not deleted
    // while we are still processing the callback

    pDirMonitorEntry->IOAddRef();

    // Release for the current Asynch operation
    // Should not send IO ref count to 0

    DBG_REQUIRE(pDirMonitorEntry->IORelease());

    BOOL fRequestNotification = FALSE;

    // There has been a change in the directory we were monitoring
    // carry out whatever work we need to do.

    if (!pDirMonitorEntry->m_fInCleanup)
    {
        pDirMonitorEntry->m_pDirMonitor->SerialComplLock();
        // BUG Under stress ActOnNotification has been initiating a chain of events
        // leading to an AV. For Beta 3 we think we can ignore these AV. For the final
        // product we need to rework the critical sections for the template manager and
        // the include file table.
        TRY
            fRequestNotification = pDirMonitorEntry->ActOnNotification(dwCompletionStatus, dwBytesWritten);
        CATCH(nExcept)
            // We should never get here
            DBG_ASSERT(FALSE);
        END_TRY
        pDirMonitorEntry->m_pDirMonitor->SerialComplUnlock();
    }

    // If we aren't cleaning up and ActOnNotification returned TRUE
    // then make another Asynch notification request. We check m_fInCleanup
    // again because ActOnNotification may have caused it to change

    if (!pDirMonitorEntry->m_fInCleanup && fRequestNotification)
    {
       fRequestNotification = pDirMonitorEntry->RequestNotification();
    }

    // Remove safety ref count, may cause IO ref count to go to 0

    pDirMonitorEntry->IORelease();

    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitor] Notification call-back ending\n"));
    }
}


CDirMonitorEntry *
CDirMonitor::FindEntry(
    LPCSTR pszPath
    )
/*++

Routine Description:

    Searches the list of entries for the specified path

Arguments:

    pszPath - file path, including file name

Return Value:

    pointer to the entry, allready addref'd

--*/
{
    DBG_ASSERT(pszPath);

    CDirMonitorEntry *pDME = NULL;
    FindKey(pszPath, &pDME);

    if (pDME)
    {
        if (pDME->m_fInCleanup)
        {
                // Don't hand back a DME that is being shutdown
                pDME = NULL;
        }
        else
        {
                // We found a valid DME which we are going to hand to the caller
                pDME->AddRef();
        }
    }

    return pDME;
}

LK_RETCODE
CDirMonitor::InsertEntry(
    CDirMonitorEntry *pDME
    )
/*++

Routine Description:

    Insert an entry into the list of entries for the monitor

Arguments:

    pDME - entry to insert

Return Value:

    nothing

--*/
{
    DBG_ASSERT(pDME);
    LK_RETCODE  lkResult;

    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitor] Inserting directory (DME %08x) %s\n", pDME, pDME->m_pszPath));
    }

    pDME->m_pDirMonitor = this;

    // pass a true value for the fOverwrite flag.  This allows the new entry
    // to replace the previous entry.  The previous entry should only be there
    // if the app it is associated with is being shutdown and the cleanup of
    // the DME records has yet to happen.

    lkResult = InsertRecord(pDME, true);
    
    if (lkResult == LK_SUCCESS) {
        // AddRef on the DirMonitor object to allow Cleanup to wait for all
        // DirMonitorEntries to be removed.  The problem arises when duplicates
        // are added to the hash table.  In this case, only the last entry is
        // kept so checking the size of the hash table during shutdown is not
        // good enough since the DMEs that were bounced may not have been freed
        // yet.
        AddRef();
    }
       
    return lkResult;
}

LK_RETCODE
CDirMonitor::RemoveEntry(
    CDirMonitorEntry *pDME
    )
/*++

Routine Description:

    Deletes an entry from the list of entries for the monitor

Arguments:

    pDME - entry to delete

Return Value:

    None

--*/
{
    DBG_ASSERT(pDME);

    // Release the DME's reference on the DirMonitor object.

    Release();

    LK_RETCODE lkResult = DeleteKey(pDME->m_pszPath);
    pDME->m_pDirMonitor = NULL;

    IF_DEBUG( NOTIFICATION ) {
        DBGPRINTF((DBG_CONTEXT, "[CDirMonitor] Removed DME(%08x), directory %s\n", pDME, pDME->m_pszPath));
    }

    return lkResult;
}

BOOL
CDirMonitor::Cleanup(
    VOID
    )
/*++

Routine Description:

    Pauses while all entries are cleaned up

Arguments:

    None

Return Value:

    None

--*/
{
    //BOOL fProperShutdown = FALSE;

    // Check that all DME have been released before shutting down
    // Sleep a maximum of 30 seconds before shutting down anyway

        while (Size() > 0 || m_cRefs != 1)
    {
                // At least one DME is still active, sleep and try again
                Sleep(200);
    }

    DBGPRINTF((DBG_CONTEXT, "CDirMonitor(%08x): Cleanup, entries remaining %d (Refs = %d)\n", this, Size(),m_cRefs));

    #ifdef _DEBUG
    // TODO: Use LKHASH iterator
    /*if (CHashTable::m_Count)
        {
        Lock();
        CLinkElem *pLink = CHashTable::Head();
        DBGPRINTF((DBG_CONTEXT, "Remaining CDirMonitorEntry objects:\n"));
        while (pLink)
            {
            CDirMonitorEntry *pDME = reinterpret_cast<CDirMonitorEntry *>(pLink);
            DBGPRINTF((DBG_CONTEXT, "CDirMonitorEntry(%08x), ref count = %d, io refcount = %d", pDME, pDME->m_cDirRefCount, pDME->m_cIORefCount));
            pLink = pLink->m_pNext;
            }
        Unlock();
        }
    */
    #endif //_DEBUG

    //DBG_ASSERT(fProperShutdown );


    return TRUE;
}

/************************ End of File ***********************/