fsdapis.cpp

WinCE5.0部分核心源码

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PGETFILEINFORMATIONBYHANDLE)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_GETFILEINFORMATIONBYHANDLE])(pHdl->dwHdlData, pFileInfo);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }   
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_FlushFileBuffers
 */

BOOL FSDMGR_FlushFileBuffers(PHDL pHdl)
{
    BOOL f=FALSE;

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PFLUSHFILEBUFFERS)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_FLUSHFILEBUFFERS])(pHdl->dwHdlData);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_GetFileTime
 */

BOOL FSDMGR_GetFileTime(PHDL pHdl, FILETIME *pCreation, FILETIME *pLastAccess, FILETIME *pLastWrite)
{
    BOOL f=FALSE;

#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pCreation = (FILETIME *)MapCallerPtr(pCreation, sizeof(FILETIME));
        pLastAccess = (FILETIME *)MapCallerPtr(pLastAccess, sizeof(FILETIME));
        pLastWrite = (FILETIME *)MapCallerPtr(pLastWrite, sizeof(FILETIME));
    }
#endif

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl); 
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PGETFILETIME)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_GETFILETIME])(pHdl->dwHdlData, pCreation, pLastAccess, pLastWrite);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_SetFileTime
 */

BOOL FSDMGR_SetFileTime(PHDL pHdl, CONST FILETIME *pCreation, CONST FILETIME *pLastAccess, CONST FILETIME *pLastWrite)
{
    BOOL f=FALSE;

#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pCreation = (CONST FILETIME *)MapCallerPtr((PVOID)pCreation, sizeof(FILETIME));
        pLastAccess = (CONST FILETIME *)MapCallerPtr((PVOID)pLastAccess, sizeof(FILETIME));
        pLastWrite = (CONST FILETIME *)MapCallerPtr((PVOID)pLastWrite, sizeof(FILETIME));
    }
#endif    
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {            
            __try {
                f = ((PSETFILETIME)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_SETFILETIME])(pHdl->dwHdlData, pCreation, pLastAccess, pLastWrite);
                if (f && pHdl->pVol->hNotifyHandle && pHdl->hNotify) {
                    NotifyHandleChange(pHdl->pVol->hNotifyHandle, pHdl->hNotify, FILE_NOTIFY_CHANGE_LAST_WRITE);
                }            
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_SetEndOfFile
 */

BOOL FSDMGR_SetEndOfFile(PHDL pHdl)
{
    BOOL f=FALSE;

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PSETENDOFFILE)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_SETENDOFFILE])(pHdl->dwHdlData);
                if (f && pHdl->pVol->hNotifyHandle && pHdl->hNotify) {
                    NotifyHandleChange(pHdl->pVol->hNotifyHandle, pHdl->hNotify, FILE_NOTIFY_CHANGE_LAST_WRITE);
                }
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_DeviceIoControl
 */

BOOL FSDMGR_DeviceIoControl(PHDL pHdl, DWORD dwIoControlCode, PVOID pInBuf, DWORD nInBufSize, PVOID pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned, OVERLAPPED *pOverlapped)
{
    BOOL f=FALSE;

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {            
            __try {
                switch (dwIoControlCode) {
                case IOCTL_FILE_READ_SCATTER:
                case IOCTL_FILE_WRITE_GATHER:
                    f = ReadWriteFileSg (dwIoControlCode, pHdl, (FILE_SEGMENT_ELEMENT*)pInBuf, nInBufSize, (LPDWORD)pOutBuf, pOverlapped);
                    break;
                default:    
                    f = ((PDEVICEIOCONTROL)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_DEVICEIOCONTROL])(pHdl->dwHdlData, dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned, pOverlapped);
                    break;
                }
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        PDSK pDsk;
        switch(dwIoControlCode) {
        case IOCTL_DISK_WRITE:
        case IOCTL_DISK_READ:
        case DISK_IOCTL_READ:
        case DISK_IOCTL_WRITE:
            if (!MapSgBuffers ((PSG_REQ)pInBuf, nInBufSize))
                return FALSE;
            break;
        case IOCTL_CDROM_READ_SG:
            if (!MapSgBuffers ((PCDROM_READ)pInBuf, nInBufSize))
                return FALSE;
            break;           
        default:
            break;
        }
        if (TryEnterHandle(pHdl) && (pDsk = pHdl->pVol->pDsk)) {
            // pass directly to the disk
            __try {
                f = pDsk->pDeviceIoControl((DWORD)pDsk->hDsk, dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned, pOverlapped);
                if (!f) {
                    if (ERROR_INVALID_HANDLE_STATE == GetLastError()) {
                        SetLastError(ERROR_DEVICE_NOT_AVAILABLE);
                    }
                }    
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }
    }
    return f;
}


/*  FSDMGR_CloseFile
 */

BOOL FSDMGR_CloseFile(PHDL pHdl)
{
    BOOL f = TRUE;
    PVOL pVol = pHdl->pVol;

    ASSERT(VALIDSIG(pHdl, HFILE_SIG));

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                pHdl->dwFlags |= HDL_INVALID;
                f = ((PCLOSEFILE)pVol->pDsk->pFSD->apfnFile[FILEAPI_CLOSEFILE])(pHdl->dwHdlData);
                if (f) {
                    if (pHdl->hNotify && pHdl->pVol->hNotifyHandle)
                        NotifyCloseHandle(pHdl->pVol->hNotifyHandle, pHdl->hNotify);
                }
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }
    }

    if (f) {
        DeallocFSDHandle(pHdl);
    }
    
    return f;
}

HANDLE FSDMGR_FindFirstChangeNotificationW(PVOL pVol, HANDLE hProc, LPCWSTR lpPathName, BOOL bWatchSubtree, DWORD dwNotifyFilter)
{
    HANDLE h = INVALID_HANDLE_VALUE;
    
    WaitForVolume(pVol);
    if (TryEnterVolume(pVol)) {
        __try {
            if (pVol->hNotifyHandle && ((wcscmp( lpPathName, L"\\") == 0) || (((PGETFILEATTRIBUTESW)pVol->pDsk->pFSD->apfnAFS[AFSAPI_GETFILEATTRIBUTESW])(pVol->dwVolData, lpPathName) != -1))) {
                h = NotifyCreateEvent(pVol->hNotifyHandle, hProc, lpPathName, bWatchSubtree, dwNotifyFilter);
            }    
        } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
            h = INVALID_HANDLE_VALUE;
        }    
        ExitVolume(pVol);
    }
    return h;
}

BOOL FSDMGR_GetVolumeInfo(PVOL pVol, CE_VOLUME_INFO_LEVEL InfoLevel, CE_VOLUME_INFO *pInfo)
{
    FSD_VOLUME_INFO fsdinfo;
    BOOL fRet = FALSE;

    if (pInfo) {
        memset( &fsdinfo, 0, sizeof(fsdinfo));
        fsdinfo.dwBlockSize = 4096;
        fsdinfo.cbSize = sizeof(fsdinfo);
        
        WaitForVolume(pVol);
        if (TryEnterVolume(pVol)) {
            __try {
                pVol->pDsk->pFSD->pGetVolumeInfo( pVol->pDsk, &fsdinfo); // Call into the FSD to get its information;
            } _except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
            }
            ExitVolume(pVol);
        }
        if (InfoLevel == CeVolumeInfoLevelStandard) {
            pInfo->dwAttributes = fsdinfo.dwAttributes;
            pInfo->dwBlockSize = fsdinfo.dwBlockSize;
            pInfo->dwFlags = fsdinfo.dwFlags;
#ifdef UNDER_CE            
            if (AFS_FROM_MOUNT_FLAGS(pVol->pDsk->dwFlags) & AFS_FLAG_HIDDEN) {
                pInfo->dwAttributes |= CE_VOLUME_ATTRIBUTE_HIDDEN;
            }
            if (AFS_FROM_MOUNT_FLAGS(pVol->pDsk->dwFlags) & AFS_FLAG_BOOTABLE) {
                pInfo->dwAttributes |= CE_VOLUME_ATTRIBUTE_BOOT;
            }
            if (AFS_FROM_MOUNT_FLAGS(pVol->pDsk->dwFlags) & AFS_FLAG_SYSTEM) {
                pInfo->dwAttributes |= CE_VOLUME_ATTRIBUTE_SYSTEM;
            }
#endif // UNDER_CE            
            LockStoreMgr();
            CStore *pStore = pVol->pDsk->pStore;
            CPartition *pPartition = pVol->pDsk->pPartition;
            if (pStore && IsValidStore(pStore)) {
                pInfo->dwFlags |= CE_VOLUME_FLAG_STORE;
                if (pStore->m_si.dwAttributes & STORE_ATTRIBUTE_READONLY) {
                    pInfo->dwAttributes |= CE_VOLUME_ATTRIBUTE_READONLY;
                }
                if (pStore->m_si.dwAttributes & STORE_ATTRIBUTE_REMOVABLE){
                    pInfo->dwAttributes |= CE_VOLUME_ATTRIBUTE_REMOVABLE;
                }
                wcsncpy( pInfo->szStoreName, pStore->m_szDeviceName, STORENAMESIZE-1);
                pInfo->szStoreName[STORENAMESIZE-1] = 0;
                if (pPartition && pStore->IsValidPartition(pPartition)) {
                    if (pPartition->m_pi.dwAttributes & PARTITION_ATTRIBUTE_READONLY) {
                        pInfo->dwAttributes |= CE_VOLUME_ATTRIBUTE_READONLY;
                    }
                    wcsncpy( pInfo->szPartitionName, pPartition->m_szPartitionName, PARTITIONNAMESIZE-1);
                    pInfo->szPartitionName[PARTITIONNAMESIZE-1] = 0;
                } else {
                    memset( pInfo->szPartitionName, 0, sizeof(PARTITIONNAMESIZE));
                }    
            } else {
                memset( pInfo->szStoreName, 0, sizeof(STORENAMESIZE));
                memset( pInfo->szPartitionName, 0, sizeof(PARTITIONNAMESIZE));
            }
            UnlockStoreMgr();
            fRet = TRUE;
        } 
    }    
    return fRet;
}

BOOL FSDMGR_FsIoControl(PVOL pVol, DWORD dwIoControlCode, PVOID pInBuf, DWORD nInBufSize, PVOID pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned, OVERLAPPED *pOverlapped)
{
    BOOL f=FALSE;
    
    WaitForVolume(pVol);
    if (TryEnterVolume(pVol)) {
#ifdef UNDER_CE       
        switch(dwIoControlCode) {
            case FSSCTL_FLUSH_BUFFERS:
                FSDMGR_CommitAllFiles(pVol);        
                break;
            case FSCTL_GET_VOLUME_INFO:
                if (pInBuf && pOutBuf) {
                    CE_VOLUME_INFO_LEVEL InfoLevel = *((CE_VOLUME_INFO_LEVEL *)pInBuf);
                    CE_VOLUME_INFO *pInfo = (CE_VOLUME_INFO *)pOutBuf;
                    f = FSDMGR_GetVolumeInfo( pVol, InfoLevel, pInfo);
                }    
                break;            
            default:                
                __try { 
                    f = ((PFSIOCONTROL)pVol->pDsk->pFSD->apfnAFS[AFSAPI_FSIOCONTROL])(pVol->dwVolData, dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned, pOverlapped);
                } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                    SetLastError(ERROR_ACCESS_DENIED);
                }
                break;
        }  
#else 
        __try { 
            f = ((PFSIOCONTROL)pVol->pDsk->pFSD->apfnAFS[AFSAPI_FSIOCONTROL])(pVol->dwVolData, dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned, pOverlapped);
        } __except(EXCEPTION_EXECUTE_HANDLER) {
            SetLastError(ERROR_ACCESS_DENIED);
        }
#endif // UNDER_CE    

        ExitVolume(pVol);
    }    
    return f;
}

BOOL FSDMGR_LockFileEx(PHDL pHdl, DWORD dwFlags, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped)
{
    BOOL f = FALSE;

    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PLOCKFILEEX)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_LOCKFILEEX])(pHdl->dwHdlData, dwFlags, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, lpOverlapped);
            }
            __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }
    }
    else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}

BOOL FSDMGR_UnlockFileEx(PHDL pHdl, DWORD dwReserved, DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh, LPOVERLAPPED lpOverlapped)
{
    BOOL f = FALSE;

    if (pHdl->dwFlags & HDL_FILE) {        
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PUNLOCKFILEEX)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_UNLOCKFILEEX])(pHdl->dwHdlData, dwReserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh, lpOverlapped);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }
    }
    else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}