stgapi.cpp

WinCE5.0部分核心源码

    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        DEBUGMSG(1, (TEXT("DeletePartition failed due to insufficient trust\r\n")));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
#endif // UNDER_CE    
    __try {        
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->DeletePartition( szPartitionName);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}

HANDLE WINAPI STG_OpenPartition(PSTOREHANDLE pStoreHandle, LPCTSTR szPartitionName)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_OpenPartition(0x%08X) Name=%s\r\n", pStoreHandle,szPartitionName));
    HANDLE hPartition = INVALID_HANDLE_VALUE;
    __try {
#ifdef UNDER_CE        
        // map input buffer
        if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
            // make this call inside the exception handler in case szPartitionName inaccessible
            szPartitionName = (LPCTSTR)MapCallerPtr((LPVOID)szPartitionName, _tcslen(szPartitionName) * sizeof(TCHAR));
        }
#endif        
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->OpenPartition( szPartitionName, &hPartition, pStoreHandle->hProc);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return hPartition;
}



BOOL WINAPI STG_MountPartition(PSTOREHANDLE pStoreHandle)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_MountPartition(0x%08X)\r\n", pStoreHandle));

#ifdef UNDER_CE
    // untrusted callers cannot mount a dismounted partition
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        DEBUGMSG(1, (TEXT("MountPartition failed due to insufficient trust\r\n")));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
#endif // UNDER_CE
    __try {
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->MountPartition( pStoreHandle->pPartition);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}

BOOL WINAPI STG_DismountPartition(PSTOREHANDLE pStoreHandle)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_DismountPartition(0x%08X)\r\n", pStoreHandle));

#ifdef UNDER_CE
    // untrusted callers cannot dismount a mounted partition
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        DEBUGMSG(1, (TEXT("DismountPartition failed due to insufficient trust\r\n")));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
#endif // UNDER_CE
    __try {
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->UnmountPartition( pStoreHandle->pPartition);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}

BOOL WINAPI STG_RenamePartition(PSTOREHANDLE pStoreHandle, LPCTSTR szNewName)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_RenamePartition(0x%08X) Name=%s\r\n", pStoreHandle, szNewName));

#ifdef UNDER_CE
    // untrusted callers cannot rename a partition
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        DEBUGMSG(1, (TEXT("RenamePartition failed due to insufficient trust\r\n")));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
#endif // UNDER_CE
    __try {
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->RenameParttion(pStoreHandle->pPartition, szNewName);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}


BOOL WINAPI STG_SetPartitionAttributes(PSTOREHANDLE pStoreHandle, DWORD dwAttrs)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_SetPartitionAttributes(0x%08X) Attrs=%08X\r\n", pStoreHandle, dwAttrs));

#ifdef UNDER_CE
    // untrusted callers cannot set partition attributes
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        DEBUGMSG(1, (TEXT("SetPartitionAttributes failed due to insufficient trust\r\n")));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
#endif // UNDER_CE
    __try {
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->SetPartitionAttributes(pStoreHandle->pPartition, dwAttrs);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}

BOOL   WINAPI STG_DeviceIoControl(PSTOREHANDLE pStoreHandle, DWORD dwIoControlCode, PVOID pInBuf, DWORD nInBufSize, PVOID pOutBuf, DWORD nOutBufSize, PDWORD pBytesReturned, OVERLAPPED *pOverlapped)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_DeviceIoControl(0x%08X) IoCode=%ld\r\n", pStoreHandle, dwIoControlCode));

#ifdef UNDER_CE
    // untrusted callers cannot call trusted ioctls
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        if (IsTrustedIoctl(dwIoControlCode)) {
            DEBUGMSG(1, (TEXT("DeviceIoControl(ioctl=0x%08X) failed due to insufficient trust\r\n"), dwIoControlCode));
            SetLastError(ERROR_ACCESS_DENIED);
            return FALSE;
        }
        
        // map input/output buffers for untrusted ioctls
        pInBuf = MapCallerPtr(pInBuf, nInBufSize);
        pOutBuf = MapCallerPtr(pOutBuf, nOutBufSize);
    }
#endif // UNDER_CE
    __try {
        if (IsValidHandle(pStoreHandle) && !(pStoreHandle->dwFlags & STOREHANDLE_TYPE_SEARCH)) {
            dwError = pStoreHandle->pStore->DeviceIoControl(pStoreHandle->pPartition, dwIoControlCode, pInBuf, nInBufSize, pOutBuf, nOutBufSize, pBytesReturned);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}


BOOL WINAPI STG_GetPartitionInfo(PSTOREHANDLE pStoreHandle, PPARTINFO pInfo)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_GetPartitionInfo(0x%08X)\r\n", pStoreHandle));

#ifdef UNDER_CE
    // map output pointer
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pInfo = (PPARTINFO)MapCallerPtr(pInfo, sizeof(PARTINFO));
    }
#endif // UNDER_CE
    __try {    
        if (pInfo->cbSize == sizeof(PARTINFO)) {
            if (IsValidHandle(pStoreHandle)) {
                dwError = pStoreHandle->pStore->GetPartitionInfo(pStoreHandle->pPartition, pInfo);
            } else {
                dwError = ERROR_BAD_ARGUMENTS;
            }
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }   
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}


BOOL WINAPI STG_FormatPartition(PSTOREHANDLE pStoreHandle, DWORD bPartType, BOOL bAuto)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_FormatPartition(0x%08X) PartType=%ld Auto=%s\r\n", pStoreHandle, bPartType, bAuto ? L"TRUE" : L"FALSE"));

#ifdef UNDER_CE
    // untrusted callers cannot format a partition
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        DEBUGMSG(1, (TEXT("FormatPartition failed due to insufficient trust\r\n")));
        SetLastError(ERROR_ACCESS_DENIED);
        return FALSE;
    }
#endif // UNDER_CE
    __try {
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->FormatPartition(pStoreHandle->pPartition, (BYTE)bPartType, bAuto);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
        if (dwError != ERROR_SUCCESS) {
            SetLastError(dwError);
        }    
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    return (dwError == ERROR_SUCCESS);
}

HANDLE WINAPI STG_FindFirstPartition(PSTOREHANDLE pStoreHandle, PPARTINFO pInfo)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_FindFirstPartition(0x%08X)\r\n", pStoreHandle));
    HANDLE hSearch = INVALID_HANDLE_VALUE;

#ifdef UNDER_CE        
    // map untrusted output pointer
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pInfo = (PPARTINFO)MapCallerPtr(pInfo, sizeof(PARTINFO));
    }
#endif // UNDER_CE
    __try {
        if (pInfo->cbSize == sizeof(PARTINFO)) {
            if (IsValidHandle(pStoreHandle)) {
                dwError = pStoreHandle->pStore->FindFirstPartition(pInfo, &hSearch, pStoreHandle->hProc);
            } else {
                dwError = ERROR_BAD_ARGUMENTS;
            }
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }   
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return hSearch;
}


BOOL WINAPI STG_FindNextPartition(SEARCHPARTITION *pSearch, PPARTINFO pInfo)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_FindNextPartition(0x%08X)\r\n", pSearch));

#ifdef UNDER_CE
    // map untrusted output pointer
    if (PSLGetCallerTrust() != OEM_CERTIFY_TRUST) {
        pInfo = (PPARTINFO)MapCallerPtr(pInfo, sizeof(PARTINFO));
    }
#endif // UNDER_CE
    __try {
        if (pInfo->cbSize == sizeof(PARTINFO)) {
            if (IsValidHandle(pSearch)) {
                dwError = pSearch->pStore->FindNextPartition(pSearch, pInfo);
            } else {
                dwError = ERROR_BAD_ARGUMENTS;
            }
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }   
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}

BOOL WINAPI STG_FindClosePartition(SEARCHPARTITION *pSearch)
{
    DWORD dwError = ERROR_SUCCESS;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_FindClosePartition(0x%08X)\r\n", pSearch));
    __try {
        if (IsValidHandle(pSearch)) {
            dwError = pSearch->pStore->FindClosePartition(pSearch);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }
    return (ERROR_SUCCESS == dwError);
}

#ifndef UNDER_CE
BOOL WINAPI STG_SetPartitionSize(PSTOREHANDLE pStoreHandle, DWORD dwHighSec, DWORD dwLowSec)
{
    DWORD dwError = ERROR_SUCCESS;
    SECTORNUM snNumSectors = ((SECTORNUM)dwHighSec << 32) | dwLowSec;
    DEBUGMSG( ZONE_STOREAPI, (L"FSDMGR:STG_SetPartitionSize(0x%08X) %ld(0x%08X%08X)\r\n",
        pStoreHandle, dwLowSec, (DWORD)(snNumSectors >> 32), (DWORD)snNumSectors));

    __try {
        if (IsValidHandle(pStoreHandle)) {
            dwError = pStoreHandle->pStore->SetPartitionSize( pStoreHandle->pPartition, snNumSectors);
        } else {
            dwError = ERROR_BAD_ARGUMENTS;
        }
    } __except( EXCEPTION_EXECUTE_HANDLER) {
        dwError = ERROR_BAD_ARGUMENTS;
    }
    if (dwError != ERROR_SUCCESS) {
        SetLastError(dwError);
    }    
    return (dwError == ERROR_SUCCESS);
}
#endif // !UNDER_CE

#ifdef __cplusplus
}
#endif /* __cplusplus */