lockmgrapi.cpp

来自「WinCE5.0部分核心源码」· C++ 代码 · 共 552 行 · 第 1/2 页

        }
        dwUndo |= DLIST;
        if (NULL == pFileLockList->GetRange()) {
            DEBUGMSG(1, (_T("%s failed to install lock; out of memory (new lock list range)\r\n"), pszFname));
            goto exit;
        }
        pFileLockList->SetOwner(dwFile);
    }
    pFileLockList->SetNext(NULL);

    // create lock

    pFileLock = new CFileLock();
    if (NULL == pFileLock) {
        DEBUGMSG(1, (_T("%s failed to install lock; out of memory (new lock)\r\n"), pszFname));
        goto exit;
    }
    pFileLock->SetRange(pRange);

    // add lock to owner's list

    pFileLockList->Insert(pFileLock);

    // re-insert owner's list in appropriate set

    pFileLockSet->Insert(pFileLockList);

    lrResult = LR_SUCCESS;
    dwUndo = 0;

exit:;
    if (dwUndo & DRANGE) {
        delete pRange;
    }
    if (dwUndo & DLIST) {
        delete pFileLockList;
    }
    if (dwUndo & DSET) {
        delete pFileLockSet;
        if (dwFlags & LOCKFILE_EXCLUSIVE_LOCK) {
            pFileLockCollection->SetExclusive(NULL);
        }
        else {
            pFileLockCollection->SetShared(NULL);
        }
    }
    return lrResult;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

BOOL
LXX_Unlock(
    PVOID pvLockContainer,
    DWORD dwFile,
    DWORD dwReserved,
    DWORD nNumberOfBytesToUnlockLow,
    DWORD nNumberOfBytesToUnlockHigh,
    LPOVERLAPPED lpOverlapped
    )
{
    SETFNAME(_T("LXX_Unlock"));

    CFileLockCollection *pFileLockCollection;
    CRange Range;
    BOOL fResult = FALSE;

    if (NULL == pvLockContainer) {
        DEBUGMSG(1, (_T("%s failed to remove lock; lock container null\r\n"), pszFname));
        return FALSE;
    }
    if (0 == dwFile) {
        DEBUGMSG(1, (_T("%s failed to remove lock; file handle null\r\n"), pszFname));
        return FALSE;
    }
    if (NULL == lpOverlapped) {
        DEBUGMSG(1, (_T("%s failed to remove lock; overlapped null\r\n"), pszFname));
        return FALSE;
    }
    if ((0 == nNumberOfBytesToUnlockLow) && (0 == nNumberOfBytesToUnlockHigh)) {
        DEBUGMSG(1, (_T("%s failed to remove lock; bytes to unlock 0\r\n"), pszFname));
        return FALSE;
    }

    // only our FSD-s use lock manager, so we trust pvLockContainer (__try not required)

    pFileLockCollection = (CFileLockCollection *)pvLockContainer;
    if (SIG != pFileLockCollection->GetSignature()) {
        DEBUGMSG(1, (_T("%s failed to remove lock; bad lock container\r\n"), pszFname));
        DEBUGCHK(0);
        return FALSE;
    }

    Range.SetOffset(lpOverlapped->Offset, lpOverlapped->OffsetHigh);
    Range.SetLength(nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh);

    if (!Range.IsValid()) {
        return FALSE;
    }

    if (pFileLockCollection->IsEmpty()) {
        goto exit;
    }

    // remove lock

    // check exclusive set

    if (NULL != pFileLockCollection->GetExclusive()) {
        if (RemoveLock(pFileLockCollection->GetExclusive(), dwFile, &Range)) {
            if (pFileLockCollection->GetExclusive()->IsEmpty()) {
                delete pFileLockCollection->GetExclusive();
                pFileLockCollection->SetExclusive(NULL);
            }
            fResult = TRUE;
            goto exit;
        }
    }

    // check shared set

    if (NULL != pFileLockCollection->GetShared()) {
        if (RemoveLock(pFileLockCollection->GetShared(), dwFile, &Range)) {
            if (pFileLockCollection->GetShared()->IsEmpty()) {
                delete pFileLockCollection->GetShared();
                pFileLockCollection->SetShared(NULL);
            }
            fResult = TRUE;
            goto exit;
        }
    }

exit:;
    return fResult;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

BOOL
LXX_UnlockLocksOwnedByHandle(
    PVOID pvLockContainer,
    DWORD dwFile
    )
{
    SETFNAME(_T("LXX_UnlockLocksOwnedByHandle"));

    CFileLockCollection *pFileLockCollection;
    CFileLockList *pFileLockList;

    if (0 == dwFile) {
        DEBUGMSG(1, (_T("%s failed to remove lock(s); file handle null\r\n"), pszFname));
        return FALSE;
    }
    if (NULL == pvLockContainer) {
        DEBUGMSG(1, (_T("%s failed to remove lock(s); lock container null\r\n"), pszFname));
        return FALSE;
    }

    // only our FSD-s use lock manager, so we trust pvLockContainer (__try not required)

    pFileLockCollection = (CFileLockCollection *)pvLockContainer;
    if (SIG != pFileLockCollection->GetSignature()) {
        DEBUGMSG(1, (_T("%s failed to remove lock(s); bad lock container\r\n"), pszFname));
        DEBUGCHK(0);
        return FALSE;
    }

    // check exclusive set

    if (NULL != pFileLockCollection->GetExclusive()) {
        pFileLockList = pFileLockCollection->GetExclusive()->Remove(dwFile);
        if (NULL != pFileLockList) {
            delete pFileLockList;
            if (pFileLockCollection->GetExclusive()->IsEmpty()) {
                delete pFileLockCollection->GetExclusive();
                pFileLockCollection->SetExclusive(NULL);
            }
        }
    }

    // check shared set

    if (NULL != pFileLockCollection->GetShared()) {
        pFileLockList = pFileLockCollection->GetShared()->Remove(dwFile);
        if (NULL != pFileLockList) {
            delete pFileLockList;
            if (pFileLockCollection->GetShared()->IsEmpty()) {
                delete pFileLockCollection->GetShared();
                pFileLockCollection->SetShared(NULL);
            }
        }
    }

    return TRUE;
}

// ----------------------------------------------------------------------------
// ----------------------------------------------------------------------------

BOOL
LXX_AuthorizeAccess(
    PVOID pvLockContainer,
    DWORD dwFile,
    BOOL fRead,
    DWORD dwFilePositionLow,
    DWORD dwFilePositionHigh,
    DWORD nBytesToBeAccessed
    )
{
    SETFNAME(_T("LXX_AuthorizeAccess"));

    CFileLockCollection *pFileLockCollection;
    CRange Range;
    BOOL fResult = FALSE;

    if (0 == dwFile) {
        DEBUGMSG(1, (_T("%s failed to authorize access; file handle null\r\n"), pszFname));
        return FALSE;
    }
    if (NULL == pvLockContainer) {
        DEBUGMSG(1, (_T("%s failed to authorize access; lock container null\r\n"), pszFname));
        return FALSE;
    }

    // only our FSD-s use lock manager, so we trust pvLockContainer (__try not required)

    pFileLockCollection = (CFileLockCollection *)pvLockContainer;
    if (SIG != pFileLockCollection->GetSignature()) {
        DEBUGMSG(1, (_T("%s failed to authorize access; bad lock container\r\n"), pszFname));
        DEBUGCHK(0);
        return FALSE;
    }

    // create range

    Range.SetOffset(dwFilePositionLow, dwFilePositionHigh);
    Range.SetLength(nBytesToBeAccessed, 0);

    if (!Range.IsValid()) {
        return FALSE;
    }

    // if read, don't check shared set

    if (fRead) {
        if (NULL != pFileLockCollection->GetExclusive()) {
            // ignore owner's list
            if (pFileLockCollection->GetExclusive()->IsConflict(&Range, dwFile)) {
                goto exit;
            }
        }
    }
    else {
        if (NULL != pFileLockCollection->GetExclusive()) {
            // ignore owner's list
            if (pFileLockCollection->GetExclusive()->IsConflict(&Range, dwFile)) {
                goto exit;
            }
        }
        if (NULL != pFileLockCollection->GetShared()) {
            // don't ignore owner's list
            if (pFileLockCollection->GetShared()->IsConflict(&Range)) {
                goto exit;
            }
        }
    }

    fResult = TRUE;

exit:;
    return fResult;
}