fsdapis.cpp

WinCE5.0部分核心源码

            f = ((PREGISTERFILESYSTEMFUNCTION)pVol->pDsk->pFSD->apfnAFS[AFSAPI_REGISTERFILESYSTEMFUNCTION])(pVol->dwVolData, pfn);
        } __except(EXCEPTION_EXECUTE_HANDLER) {
            SetLastError(ERROR_ACCESS_DENIED);
        }
        ExitVolume(pVol);
    }    
    return f;
}


/*  FSDMGR_FindFirstFileW
 *
 *  ENTRY
 *      pVol -> VOL structure
 *      hProc == handle of originating process
 *      pwsFileSpec -> name of file(s), wildcards allowed
 *      pfd -> WIN32_FIND_DATAW to be filled in on success
 *
 *  EXIT
 *      HANDLE to be used with subsequent FindNextFileW() and FindClose() APIs,
 *      or INVALID_HANDLE_VALUE if error.
 */

HANDLE FSDMGR_FindFirstFileW(PVOL pVol, HANDLE hProc, PCWSTR pwsFileSpec, PWIN32_FIND_DATAW pfd)
{
    HANDLE h=INVALID_HANDLE_VALUE;

    // Check caller buffer access
#ifdef UNDER_CE    
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pfd = (PWIN32_FIND_DATAW)MapCallerPtr(pfd, sizeof(WIN32_FIND_DATA));
    }
#endif

    WaitForVolume(pVol);
    if (TryEnterVolume(pVol)) {
        __try {
            h = ((PFINDFIRSTFILEW)pVol->pDsk->pFSD->apfnAFS[AFSAPI_FINDFIRSTFILEW])(pVol->dwVolData, hProc, pwsFileSpec, pfd);
            if (h != INVALID_HANDLE_VALUE) {
                h = AllocFSDHandle(pVol, hProc, NULL, (DWORD)h, HDL_SEARCH);
            }   
        } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
            h = INVALID_HANDLE_VALUE;
            SetLastError(ERROR_ACCESS_DENIED);
        }
        ExitVolume(pVol);
    }    
    return h;
}


/*  FSDMGR_FindNextFileW
 *
 *  ENTRY
 *      pHdl -> HDL structure
 *      pfd -> WIN32_FIND_DATAW to be filled in on success
 *
 *  EXIT
 *      TRUE if successful, FALSE if not (call GetLastError for error code)
 */

BOOL FSDMGR_FindNextFileW(PHDL pHdl, PWIN32_FIND_DATAW pfd)
{
    BOOL f=FALSE;

    ASSERT(VALIDSIG(pHdl, HSEARCH_SIG));

    // Check caller buffer access
#ifdef UNDER_CE    
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pfd = (PWIN32_FIND_DATAW)MapCallerPtr(pfd, sizeof(WIN32_FIND_DATA));
    }
#endif

    if (pHdl->dwFlags & HDL_SEARCH) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PFINDNEXTFILEW)pHdl->pVol->pDsk->pFSD->apfnFind[FINDAPI_FINDNEXTFILEW])(pHdl->dwHdlData, pfd);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_FindClose
 *
 *  ENTRY
 *      pHdl -> HDL structure
 *
 *  EXIT
 *      TRUE if successful, FALSE if not (call GetLastError for error code)
 */

BOOL FSDMGR_FindClose(PHDL pHdl)
{
    BOOL f = TRUE;
 
    ASSERT(VALIDSIG(pHdl, HSEARCH_SIG));
        
    if (pHdl->dwFlags & HDL_SEARCH) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PFINDCLOSE)pHdl->pVol->pDsk->pFSD->apfnFind[FINDAPI_FINDCLOSE])(pHdl->dwHdlData);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }                
            ExitHandle(pHdl);
        }    
    }
    
    if (f) {
        DeallocFSDHandle(pHdl);
    }
        
    return f;
}


/*  FSDMGR_CreateFileW
 *
 *  ENTRY
 *      pVol -> VOL structure
 *      hProc == handle of originating process
 *      pwsFileName
 *
 *  EXIT
 *      TRUE if successful, FALSE if not (call GetLastError for error code)
 */

HANDLE FSDMGR_CreateFileW(PVOL pVol, HANDLE hProc, PCWSTR pwsFileName, DWORD dwAccess, DWORD dwShareMode, PSECURITY_ATTRIBUTES pSecurityAttributes, DWORD dwCreate, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
    HANDLE h=INVALID_HANDLE_VALUE;
    BOOL bDevice = FALSE;
    HANDLE hNotify = NULL;

    WaitForVolume(pVol);
    if (TryEnterVolume(pVol)) {
        __try {
            DWORD dwAttr = FSDMGR_GetFileAttributesW(pVol, pwsFileName);
            h = ((PCREATEFILEW)pVol->pDsk->pFSD->apfnAFS[AFSAPI_CREATEFILEW])(pVol->dwVolData, hProc, pwsFileName, dwAccess, dwShareMode, pSecurityAttributes, dwCreate, dwFlagsAndAttributes, hTemplateFile);
            if (h != INVALID_HANDLE_VALUE) {        
                if (pwsFileName[wcslen(pwsFileName)-1] == L':') {
                    bDevice = TRUE;
                } 
                if (!bDevice && pVol->hNotifyHandle) {
                    if (-1 == dwAttr) {
                        // new file was added because it did not exist prior to calling CreateFile
                        NotifyPathChange( pVol->hNotifyHandle, pwsFileName, FALSE, FILE_ACTION_ADDED);
                    } else if ((CREATE_ALWAYS == dwCreate) || (TRUNCATE_EXISTING == dwCreate)) {
                        // existing file was re-created
                        NotifyPathChange( pVol->hNotifyHandle, pwsFileName, FALSE, FILE_ACTION_MODIFIED);
                    }
                    // else: an existing file was opened, so don't send a notification

                    // create a notification handle to associate with the file handle
                    hNotify  = NotifyCreateFile(pVol->hNotifyHandle, pwsFileName);
                }
#ifndef DEBUG
                h = AllocFSDHandle(pVol, hProc, hNotify, (DWORD)h, HDL_FILE);
#else
                if ((wcsicmp(pwsFileName, L"\\reg:") == 0) || (wcsicmp( pwsFileName, L"\\con") == 0)) {
                    h = AllocFSDHandle(pVol, hProc, hNotify, (DWORD)h, HDL_FILE | HDL_CONSOLE);
                } else {
                    h = AllocFSDHandle(pVol, hProc, hNotify, (DWORD)h, HDL_FILE);
                }
#endif
            } else {
                if (pwsFileName && (wcscmp( pwsFileName, L"\\VOL:") == 0)) {
                    h = AllocFSDHandle( pVol, hProc, NULL, 0, HDL_PSUEDO);
                }
            }    
        } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
            h = INVALID_HANDLE_VALUE;
            SetLastError(ERROR_ACCESS_DENIED);
        }
        ExitVolume(pVol);
    }    
    return h;
}


/*  FSDMGR_ReadFile
 */

BOOL FSDMGR_ReadFile(PHDL pHdl, PVOID pBuffer, DWORD cbRead, PDWORD pcbRead, OVERLAPPED *pOverlapped)
{
    BOOL f = FALSE;

#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pBuffer = MapCallerPtr(pBuffer, cbRead);
        pcbRead = (PDWORD)MapCallerPtr(pcbRead, sizeof(DWORD));
    }
#endif
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PREADFILE)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_READFILE])(pHdl->dwHdlData, pBuffer, cbRead, pcbRead, pOverlapped);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_ReadFileWithSeek
 */

BOOL FSDMGR_ReadFileWithSeek(PHDL pHdl, PVOID pBuffer, DWORD cbRead, PDWORD pcbRead, OVERLAPPED *pOverlapped, DWORD dwLowOffset, DWORD dwHighOffset)
{
    BOOL f = FALSE;

#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pBuffer = MapCallerPtr(pBuffer, cbRead);
        pcbRead = (PDWORD)MapCallerPtr(pcbRead, sizeof(DWORD));
    }
#endif
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {            
            __try {
                if (pBuffer == NULL && cbRead == 0 && !(pHdl->pVol->pDsk->pFSD->dwFlags & FSD_FLAGS_PAGEABLE)) {
                    DEBUGMSG( ZONE_APIS, (L"FSDMGR_ReadFileWithSeek pDsk=%08X - Reporting back as paging not supported !!!\r\n", pHdl->pVol->pDsk));
                    SetLastError(ERROR_NOT_SUPPORTED);
                    f = FALSE;
                } else {
                    f = ((PREADFILEWITHSEEK)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_READFILEWITHSEEK])(pHdl->dwHdlData, pBuffer, cbRead, pcbRead, pOverlapped, dwLowOffset, dwHighOffset);
                }    
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return f;
}


/*  FSDMGR_WriteFile
 */

BOOL FSDMGR_WriteFile(PHDL pHdl, PCVOID pBuffer, DWORD cbWrite, PDWORD pcbWritten, OVERLAPPED *pOverlapped)
{
    BOOL f = FALSE;

#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pBuffer = MapCallerPtr((PVOID)pBuffer, cbWrite);
        pcbWritten = (PDWORD)MapCallerPtr(pcbWritten, sizeof(DWORD));
    }
#endif    
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PWRITEFILE)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_WRITEFILE])(pHdl->dwHdlData, pBuffer, cbWrite, pcbWritten, pOverlapped);
                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_WriteFileWithSeek
 */

BOOL FSDMGR_WriteFileWithSeek(PHDL pHdl, PCVOID pBuffer, DWORD cbWrite, PDWORD pcbWritten, OVERLAPPED *pOverlapped, DWORD dwLowOffset, DWORD dwHighOffset)
{
    BOOL f = FALSE;

#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pBuffer = MapCallerPtr((PVOID)pBuffer, cbWrite);
        pcbWritten = (PDWORD)MapCallerPtr(pcbWritten, sizeof(DWORD));
    }
#endif

    // do NOT call WaitForHandle on ReadFileWithSeek/WriteFileWithSeek
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);
        if (TryEnterHandle(pHdl)) {
            __try {
                f = ((PWRITEFILEWITHSEEK)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_WRITEFILEWITHSEEK])(pHdl->dwHdlData, pBuffer, cbWrite, pcbWritten, pOverlapped, dwLowOffset, dwHighOffset);
                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_SetFilePointer
 */

DWORD FSDMGR_SetFilePointer(PHDL pHdl, LONG lDistanceToMove, PLONG pDistanceToMoveHigh, DWORD dwMoveMethod)
{
    DWORD dw=(DWORD)-1; // Should be INVALID_SET_FILE_POINTER but this is not defined in CE headers yet

    // Check caller buffer access
#ifdef UNDER_CE    
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pDistanceToMoveHigh = (PLONG)MapCallerPtr(pDistanceToMoveHigh, sizeof(LONG));
    }
#endif    
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);       
        if (TryEnterHandle(pHdl)) {        
            __try {
                dw = ((PSETFILEPOINTER)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_SETFILEPOINTER])(pHdl->dwHdlData, lDistanceToMove, pDistanceToMoveHigh, dwMoveMethod);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                dw = -1;
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }    
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return dw;
}


/*  FSDMGR_GetFileSize
 */

DWORD FSDMGR_GetFileSize(PHDL pHdl, PDWORD pFileSizeHigh)
{
    DWORD dw=INVALID_FILE_SIZE;
    // Check caller buffer access
#ifdef UNDER_CE    
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pFileSizeHigh = (PDWORD)MapCallerPtr(pFileSizeHigh, sizeof(DWORD));
    }
#endif
    if (pHdl->dwFlags & HDL_FILE) {
        WaitForHandle(pHdl);               
        if (TryEnterHandle(pHdl)) {            
            __try {
                dw = ((PGETFILESIZE)pHdl->pVol->pDsk->pFSD->apfnFile[FILEAPI_GETFILESIZE])(pHdl->dwHdlData, pFileSizeHigh);
            } __except(ReportFault(GetExceptionInformation(), 0), EXCEPTION_EXECUTE_HANDLER) {
                dw = INVALID_FILE_SIZE;
                SetLastError(ERROR_ACCESS_DENIED);
            }
            ExitHandle(pHdl);
        }
    } else {
        SetLastError(ERROR_INVALID_HANDLE);
    }
    return dw;
}


/*  FSDMGR_GetFileInformationByHandle
 */

BOOL FSDMGR_GetFileInformationByHandle(PHDL pHdl, PBY_HANDLE_FILE_INFORMATION pFileInfo)
{
    BOOL f=FALSE;


    // Check caller buffer access
#ifdef UNDER_CE
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pFileInfo = (PBY_HANDLE_FILE_INFORMATION)MapCallerPtr(pFileInfo, sizeof(BY_HANDLE_FILE_INFORMATION));
    }
#endif