file.cpp

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

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// This source code is licensed under Microsoft Shared Source License
// Version 1.0 for Windows CE.
// For a copy of the license visit http://go.microsoft.com/fwlink/?LinkId=3223.
//
#include "binfs.h"



extern "C" HANDLE FSD_CreateFileW(BinVolume *pVolume, HANDLE hProc, LPCWSTR lpFileName, DWORD dwAccess, DWORD dwShareMode, 
                            LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreate, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile)
{
    DWORD dwError =ERROR_SUCCESS;
    BinDirList *pDirectory = pVolume->pDirectory;
    HANDLE hFile = INVALID_HANDLE_VALUE;
    
    DEBUGMSG(ZONE_API, 
             (L"BINFS: FSD_CreateFileW lpFileName=%s dwAccess=%08X dwShare=%08X dwCreate=%08X dwFlags=%08X\n", 
             lpFileName, dwAccess, dwShareMode, dwCreate, dwFlagsAndAttributes));

    __try {
        if (!lpFileName || (wcslen(lpFileName) > MAX_PATH)) {
            dwError = ERROR_INVALID_PARAMETER;
        }
    } __except(EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_INVALID_PARAMETER;
    }
    if (ERROR_SUCCESS == dwError) {
        while ((*lpFileName == L'\\') || (*lpFileName == L'/'))
            lpFileName++;

        if (wcslen(lpFileName) > SYSTEM_DIR_LEN) {
            if ((wcsnicmp( lpFileName, SYSTEM_DIR, SYSTEM_DIR_LEN) == 0) && ((*(lpFileName+SYSTEM_DIR_LEN) == L'\\') || (*(lpFileName+SYSTEM_DIR_LEN) == L'/'))){
                lpFileName += SYSTEM_DIR_LEN;
                while ((*lpFileName == L'\\') || (*lpFileName == L'/')) {
                    lpFileName++;
                }
            }
        }

        while(pDirectory) {
            if (wcsicmp( pDirectory->szFileName, lpFileName) == 0) 
                break;
            pDirectory = pDirectory->pNext;
        }
        if (pDirectory) {
            if ((dwAccess & GENERIC_WRITE) || 
                (dwCreate == CREATE_NEW) || 
                (dwCreate == CREATE_ALWAYS) || 
                (dwCreate == TRUNCATE_EXISTING))
            {
                dwError = ERROR_ACCESS_DENIED;

            } else if (pDirectory->pe32 && (pDirectory->pe32->e32_objcnt > MAX_REGIONS)) {

                // this module has too many sections, fail the CreateFile call
                dwError = ERROR_BAD_FORMAT;
                RETAILMSG(1, (L"BINFS!FSD_CreateFileW: ERROR! module \"%s\" has %u o32 sections (max sections = %u)\r\n", pDirectory->szFileName, pDirectory->pe32->e32_objcnt, MAX_O32_SECTIONS));
                
            } else {
                FileHandle *pFile = new FileHandle;
                if (pFile) {
                    pFile->pDirectory = pDirectory;
                    pFile->dwShareMode = dwShareMode;
                    pFile->dwPosition = 0;
                    pFile->pVolume = pVolume;
                    hFile = FSDMGR_CreateFileHandle(pVolume->hVolume, hProc, (PFILE)pFile);
                } else {
                    dwError = GetLastError();
                }    
            }    
        } else {
            dwError = ERROR_FILE_NOT_FOUND;
        }    
    }    
            
    if (ERROR_SUCCESS != dwError) {
        SetLastError( dwError);
    }
    return hFile;
}


extern "C" BOOL FSD_CloseFile(FileHandle *pFile)
{
    delete pFile;
    return TRUE;
}

extern "C" BOOL FSD_ReadFile(FileHandle *pFile, BYTE *pBuffer, DWORD dwBytesToRead, LPDWORD lpNumBytesRead, LPOVERLAPPED lpOverlapped)
{
    DWORD dwError = ERROR_SUCCESS;
    DWORD dwRead = 0;

    if (dwBytesToRead+pFile->dwPosition > pFile->pDirectory->dwRealFileSize)
        dwBytesToRead = pFile->pDirectory->dwRealFileSize-pFile->dwPosition;

    if (dwBytesToRead) {
        if (!pFile->pDirectory->po32) {
            dwRead = GetFileData(pFile->pVolume, pFile->pDirectory, pFile->dwPosition, pBuffer, dwBytesToRead);
            pFile->dwPosition += dwRead;
        } else {
            dwError = ERROR_ACCESS_DENIED;
        }    
    }
    
    if (lpNumBytesRead) {
        *lpNumBytesRead = dwRead;
    }    

    if (ERROR_SUCCESS != dwError) {
        SetLastError( dwError);
    }
    return (dwError == ERROR_SUCCESS);
}



extern "C" BOOL FSD_ReadFileWithSeek( FileHandle *pFile, BYTE *pBuffer, DWORD dwBytesToRead, LPDWORD lpNumBytesRead, LPOVERLAPPED lpOverlapped,
                                 DWORD dwLowOffset, DWORD dwHighOffset)
{
    DWORD dwError = ERROR_SUCCESS;
    BOOL fSuccess = FALSE;
    DWORD dwRead = 0;

    if (dwBytesToRead) {
        if (!pFile->pDirectory->po32) {
            if (dwBytesToRead+dwLowOffset > pFile->pDirectory->dwRealFileSize)
                dwBytesToRead = pFile->pDirectory->dwRealFileSize-dwLowOffset;
            dwRead = GetFileData(pFile->pVolume, pFile->pDirectory, dwLowOffset, pBuffer, dwBytesToRead);
        } else {
            
            BinDirList Directory;
            o32_rom *po32;
            po32 = &(pFile->pDirectory->po32[dwLowOffset >> 28]);
            DEBUGCHK( dwLowOffset >> 28 < pFile->pDirectory->pe32->e32_objcnt);
            Directory.dwRegion = pFile->pDirectory->dwRegion;
            EnterCriticalSection( &pFile->pVolume->csComp);    
            pFile->pVolume->pCurCompDir = NULL;
            Directory.dwAddress = po32->o32_dataptr;
            Directory.dwRealFileSize= po32->o32_psize;
            Directory.dwCompFileSize = po32->o32_psize;
            if (po32->o32_flags & IMAGE_SCN_COMPRESSED) {
                Directory.dwRealFileSize= po32->o32_vsize;
            } 
            dwRead = GetFileData( pFile->pVolume, &Directory, dwLowOffset & 0x0fffffff, pBuffer, dwBytesToRead);
            LeaveCriticalSection(&pFile->pVolume->csComp);
#if 0            
            if (i == pFile->pDirectory->pe32->e32_objcnt) {
                dwError = ERROR_NOT_FOUND;
            }    
#endif            
        }    
    }    
    if (lpNumBytesRead) {
        *lpNumBytesRead = dwRead;
    }    
    
    if (ERROR_SUCCESS != dwError) {
        SetLastError( dwError);
    }
    return (dwError == ERROR_SUCCESS);
}

extern "C" BOOL FSD_WriteFile( FileHandle *pFile, LPCVOID buffer, DWORD dwBytesToWrite, LPDWORD lpNumBytesWritten, LPOVERLAPPED lpOverlapped)
{
    if (lpNumBytesWritten)
        *lpNumBytesWritten = 0;
    SetLastError( ERROR_ACCESS_DENIED);
    return FALSE;
}



extern "C" BOOL FSD_WriteFileWithSeek( FileHandle *pFile, LPCVOID buffer, DWORD dwBytesToWrite, LPDWORD lpNumBytesWritten, LPOVERLAPPED lpOverlapped,
                                  DWORD dwLowOffset, DWORD dwHighOffset)
{
    if (lpNumBytesWritten)
        *lpNumBytesWritten = 0;
        
    SetLastError( ERROR_ACCESS_DENIED);
    return FALSE;
}

extern "C" DWORD FSD_SetFilePointer( FileHandle *pFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod)
{
    switch( dwMoveMethod) {
        case FILE_BEGIN:
            pFile->dwPosition = lDistanceToMove;
            break;
        case FILE_CURRENT:
            pFile->dwPosition += lDistanceToMove;
            break;
        case FILE_END:
            pFile->dwPosition = pFile->pDirectory->dwRealFileSize - lDistanceToMove;
            break;
        default:
            break;
    }
    return pFile->dwPosition;
}


extern "C" DWORD FSD_GetFileSize(FileHandle *pFile, LPDWORD lpFileSizeHigh)
{
    if (lpFileSizeHigh)
        *lpFileSizeHigh = 0;
        
    return pFile->pDirectory->dwRealFileSize;
}


extern "C" BOOL FSD_GetFileInformationByHandle(FileHandle *pFile, LPBY_HANDLE_FILE_INFORMATION lpFileInfo)
{
    if (lpFileInfo) {
        if (pFile->pDirectory->dwAttributes & FILE_ATTRIBUTE_ROMMODULE) {
            lpFileInfo->dwOID = 0; /* pFile->pDirectory->dwAddress; */
        } else {