mirror of
git://source.winehq.org/git/wine.git
synced 2024-10-31 12:54:13 +00:00
786 lines
18 KiB
C
786 lines
18 KiB
C
/******************************************************************************
|
|
*
|
|
* BigBlockFile
|
|
*
|
|
* This is the implementation of a file that consists of blocks of
|
|
* a predetermined size.
|
|
* This class is used in the Compound File implementation of the
|
|
* IStorage and IStream interfaces. It provides the functionality
|
|
* to read and write any blocks in the file as well as setting and
|
|
* obtaining the size of the file.
|
|
* The blocks are indexed sequentially from the start of the file
|
|
* starting with -1.
|
|
*
|
|
* TODO:
|
|
* - Support for a transacted mode
|
|
*
|
|
* Copyright 1999 Thuy Nguyen
|
|
*
|
|
*/
|
|
|
|
#include <assert.h>
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
|
|
#include "winbase.h"
|
|
#include "winerror.h"
|
|
#include "wine/obj_storage.h"
|
|
|
|
#include "storage32.h"
|
|
|
|
/***********************************************************
|
|
* Data structures used internally by the BigBlockFile
|
|
* class.
|
|
*/
|
|
|
|
/***
|
|
* Itdentifies a single big block and the related
|
|
* information
|
|
*/
|
|
struct BigBlock
|
|
{
|
|
BigBlock * next;
|
|
DWORD index;
|
|
DWORD access_mode;
|
|
LPVOID lpBlock;
|
|
};
|
|
|
|
/***
|
|
* This structure identifies the paged that are mapped
|
|
* from the file and their position in memory. It is
|
|
* also used to hold a reference count to those pages.
|
|
*/
|
|
struct MappedPage
|
|
{
|
|
MappedPage * next;
|
|
DWORD number;
|
|
int ref;
|
|
LPVOID lpBytes;
|
|
};
|
|
|
|
#define PAGE_SIZE 131072
|
|
#define BLOCKS_PER_PAGE 256
|
|
|
|
#define NUMBER_OF_MAPPED_PAGES 100
|
|
|
|
/***********************************************************
|
|
* Prototypes for private methods
|
|
*/
|
|
static void* BIGBLOCKFILE_GetMappedView(LPBIGBLOCKFILE This,
|
|
DWORD pagenum,
|
|
DWORD desired_access);
|
|
static void BIGBLOCKFILE_ReleaseMappedPage(LPBIGBLOCKFILE This,
|
|
DWORD pagenum,
|
|
DWORD access);
|
|
static void BIGBLOCKFILE_FreeAllMappedPages(LPBIGBLOCKFILE This);
|
|
static void* BIGBLOCKFILE_GetBigBlockPointer(LPBIGBLOCKFILE This,
|
|
ULONG index,
|
|
DWORD desired_access);
|
|
static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(LPBIGBLOCKFILE This,
|
|
void* pBlock);
|
|
static void BIGBLOCKFILE_RemoveBlock(LPBIGBLOCKFILE This,
|
|
ULONG index);
|
|
static BigBlock* BIGBLOCKFILE_AddBigBlock(LPBIGBLOCKFILE This,
|
|
ULONG index);
|
|
static BigBlock* BIGBLOCKFILE_CreateBlock(ULONG index);
|
|
static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags);
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_Construct
|
|
*
|
|
* Construct a big block file. Create the file mapping object.
|
|
* Create the read only mapped pages list, the writeable mapped page list
|
|
* and the blocks in use list.
|
|
*/
|
|
BigBlockFile * BIGBLOCKFILE_Construct(
|
|
HANDLE hFile,
|
|
DWORD openFlags,
|
|
ULONG blocksize)
|
|
{
|
|
LPBIGBLOCKFILE This;
|
|
|
|
This = (LPBIGBLOCKFILE)HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlockFile));
|
|
|
|
if (This == NULL)
|
|
return NULL;
|
|
|
|
This->hfile = hFile;
|
|
|
|
if (This->hfile == INVALID_HANDLE_VALUE)
|
|
{
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
return NULL;
|
|
}
|
|
|
|
This->flProtect = BIGBLOCKFILE_GetProtectMode(openFlags);
|
|
|
|
/* create the file mapping object
|
|
*/
|
|
This->hfilemap = CreateFileMappingA(This->hfile,
|
|
NULL,
|
|
This->flProtect,
|
|
0, 0,
|
|
NULL);
|
|
|
|
if (This->hfilemap == NULL)
|
|
{
|
|
CloseHandle(This->hfile);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
return NULL;
|
|
}
|
|
|
|
/* initialize this
|
|
*/
|
|
This->filesize.LowPart = GetFileSize(This->hfile, NULL);
|
|
This->blocksize = blocksize;
|
|
|
|
/* create the mapped pages list
|
|
*/
|
|
This->maplisthead = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
|
|
|
|
if (This->maplisthead == NULL)
|
|
{
|
|
CloseHandle(This->hfilemap);
|
|
CloseHandle(This->hfile);
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
return NULL;
|
|
}
|
|
|
|
This->maplisthead->next = NULL;
|
|
|
|
/* initialize the block list
|
|
*/
|
|
This->headblock = NULL;
|
|
|
|
return This;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_Destructor
|
|
*
|
|
* Destructor. Clean up, free memory.
|
|
*/
|
|
void BIGBLOCKFILE_Destructor(
|
|
LPBIGBLOCKFILE This)
|
|
{
|
|
/* unmap all views and destroy the mapped page list
|
|
*/
|
|
BIGBLOCKFILE_FreeAllMappedPages(This);
|
|
HeapFree(GetProcessHeap(), 0, This->maplisthead);
|
|
|
|
/* close all open handles
|
|
*/
|
|
CloseHandle(This->hfilemap);
|
|
CloseHandle(This->hfile);
|
|
|
|
/* destroy this
|
|
*/
|
|
HeapFree(GetProcessHeap(), 0, This);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_GetROBigBlock
|
|
*
|
|
* Returns the specified block in read only mode.
|
|
* Will return NULL if the block doesn't exists.
|
|
*/
|
|
void* BIGBLOCKFILE_GetROBigBlock(
|
|
LPBIGBLOCKFILE This,
|
|
ULONG index)
|
|
{
|
|
/*
|
|
* block index starts at -1
|
|
* translate to zero based index
|
|
*/
|
|
if (index == 0xffffffff)
|
|
index = 0;
|
|
else
|
|
index++;
|
|
|
|
/*
|
|
* validate the block index
|
|
*
|
|
*/
|
|
if ((This->blocksize * (index + 1)) >
|
|
(This->filesize.LowPart +
|
|
(This->blocksize - (This->filesize.LowPart % This->blocksize))))
|
|
return 0;
|
|
|
|
return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_READ);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_GetBigBlock
|
|
*
|
|
* Returns the specified block.
|
|
* Will grow the file if necessary.
|
|
*/
|
|
void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index)
|
|
{
|
|
/*
|
|
* block index starts at -1
|
|
* translate to zero based index
|
|
*/
|
|
if (index == 0xffffffff)
|
|
index = 0;
|
|
else
|
|
index++;
|
|
|
|
/*
|
|
* make sure that the block physically exists
|
|
*/
|
|
if ((This->blocksize * (index + 1)) > This->filesize.LowPart)
|
|
{
|
|
ULARGE_INTEGER newSize;
|
|
|
|
newSize.HighPart = 0;
|
|
newSize.LowPart = This->blocksize * (index + 1);
|
|
|
|
BIGBLOCKFILE_SetSize(This, newSize);
|
|
}
|
|
|
|
return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_WRITE);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_ReleaseBigBlock
|
|
*
|
|
* Releases the specified block.
|
|
*/
|
|
void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock)
|
|
{
|
|
DWORD page_num;
|
|
BigBlock* theBigBlock;
|
|
|
|
if (pBlock == NULL)
|
|
return;
|
|
|
|
/*
|
|
* get the block from the block list
|
|
*/
|
|
theBigBlock = BIGBLOCKFILE_GetBigBlockFromPointer(This, pBlock);
|
|
|
|
if (theBigBlock == NULL)
|
|
return;
|
|
|
|
/*
|
|
* find out which page this block is in
|
|
*/
|
|
page_num = theBigBlock->index / BLOCKS_PER_PAGE;
|
|
|
|
/*
|
|
* release this page
|
|
*/
|
|
BIGBLOCKFILE_ReleaseMappedPage(This, page_num, theBigBlock->access_mode);
|
|
|
|
/*
|
|
* remove block from list
|
|
*/
|
|
BIGBLOCKFILE_RemoveBlock(This, theBigBlock->index);
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_SetSize
|
|
*
|
|
* Sets the size of the file.
|
|
*
|
|
*/
|
|
void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
|
|
{
|
|
if (This->filesize.LowPart == newSize.LowPart)
|
|
return;
|
|
|
|
/*
|
|
* unmap all views, must be done before call to SetEndFile
|
|
*/
|
|
BIGBLOCKFILE_FreeAllMappedPages(This);
|
|
|
|
/*
|
|
* close file-mapping object, must be done before call to SetEndFile
|
|
*/
|
|
CloseHandle(This->hfilemap);
|
|
This->hfilemap = NULL;
|
|
|
|
/*
|
|
* set the new end of file
|
|
*/
|
|
SetFilePointer(This->hfile, newSize.LowPart, NULL, FILE_BEGIN);
|
|
SetEndOfFile(This->hfile);
|
|
|
|
/*
|
|
* re-create the file mapping object
|
|
*/
|
|
This->hfilemap = CreateFileMappingA(This->hfile,
|
|
NULL,
|
|
This->flProtect,
|
|
0, 0,
|
|
NULL);
|
|
|
|
This->filesize.LowPart = newSize.LowPart;
|
|
This->filesize.HighPart = newSize.HighPart;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_GetSize
|
|
*
|
|
* Returns the size of the file.
|
|
*
|
|
*/
|
|
ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This)
|
|
{
|
|
return This->filesize;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_GetBigBlockPointer [PRIVATE]
|
|
*
|
|
* Returns a pointer to the specified block.
|
|
*/
|
|
static void* BIGBLOCKFILE_GetBigBlockPointer(
|
|
LPBIGBLOCKFILE This,
|
|
ULONG index,
|
|
DWORD desired_access)
|
|
{
|
|
DWORD page_num, block_num;
|
|
void * pBytes;
|
|
BigBlock *aBigBlock;
|
|
|
|
/* get the big block from the list or add it to the list
|
|
*/
|
|
aBigBlock = BIGBLOCKFILE_AddBigBlock(This, index);
|
|
|
|
if (aBigBlock == NULL)
|
|
return NULL;
|
|
|
|
/* we already have an address for this block
|
|
*/
|
|
if (aBigBlock->lpBlock != NULL)
|
|
{
|
|
/* make sure the desired access matches what we already have
|
|
*/
|
|
if (aBigBlock->access_mode == desired_access)
|
|
return aBigBlock->lpBlock;
|
|
else
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* else aBigBlock->lpBigBlock == NULL, it's a new block
|
|
*/
|
|
|
|
/* find out which page this block is in
|
|
*/
|
|
page_num = index / BLOCKS_PER_PAGE;
|
|
|
|
/* offset of the block in the page
|
|
*/
|
|
block_num = index % BLOCKS_PER_PAGE;
|
|
|
|
/* get a pointer to the first byte in the page
|
|
*/
|
|
pBytes = BIGBLOCKFILE_GetMappedView(This, page_num, desired_access);
|
|
|
|
if (pBytes == NULL)
|
|
return NULL;
|
|
|
|
/* initialize block
|
|
*/
|
|
aBigBlock->lpBlock = ((BYTE*)pBytes + (block_num*This->blocksize));
|
|
aBigBlock->access_mode = desired_access;
|
|
|
|
return aBigBlock->lpBlock;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_CreateBlock [PRIVATE]
|
|
*
|
|
* Creates a node of the blocks list.
|
|
*/
|
|
static BigBlock* BIGBLOCKFILE_CreateBlock(
|
|
ULONG index)
|
|
{
|
|
BigBlock *newBigBlock;
|
|
|
|
/* create new list node
|
|
*/
|
|
newBigBlock = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlock));
|
|
|
|
if (newBigBlock == NULL)
|
|
return NULL;
|
|
|
|
/* initialize node
|
|
*/
|
|
newBigBlock->index = index;
|
|
newBigBlock->lpBlock = NULL;
|
|
|
|
return newBigBlock;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_AddBigBlock [PRIVATE]
|
|
*
|
|
* Returns the specified block from the blocks list.
|
|
* If the block is not found in the list, we will create it and add it to the
|
|
* list.
|
|
*/
|
|
static BigBlock* BIGBLOCKFILE_AddBigBlock(
|
|
LPBIGBLOCKFILE This,
|
|
ULONG index)
|
|
{
|
|
BigBlock *current = This->headblock;
|
|
BigBlock *newBigBlock;
|
|
|
|
if (current == NULL) /* empty list */
|
|
{
|
|
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
|
|
|
|
if (newBigBlock != NULL)
|
|
{
|
|
newBigBlock->next = NULL;
|
|
This->headblock = newBigBlock;
|
|
}
|
|
|
|
return newBigBlock;
|
|
}
|
|
else
|
|
{
|
|
/*
|
|
* special handling for head of the list
|
|
*/
|
|
|
|
if (current->index == index) /* it's already here */
|
|
return current;
|
|
else if (current->index > index) /* insertion at head of the list */
|
|
{
|
|
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
|
|
|
|
if (newBigBlock != NULL)
|
|
{
|
|
newBigBlock->next = current;
|
|
This->headblock = newBigBlock;
|
|
}
|
|
|
|
return newBigBlock;
|
|
}
|
|
}
|
|
|
|
/* iterate through rest the list
|
|
*/
|
|
while (current->next != NULL)
|
|
{
|
|
if (current->next->index == index) /* found it */
|
|
{
|
|
return current->next;
|
|
}
|
|
else if (current->next->index > index) /* it's not in the list */
|
|
{
|
|
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
|
|
|
|
if (newBigBlock != NULL)
|
|
{
|
|
newBigBlock->next = current->next;
|
|
current->next = newBigBlock;
|
|
}
|
|
|
|
return newBigBlock;
|
|
}
|
|
else
|
|
current = current->next;
|
|
}
|
|
|
|
/*
|
|
* insertion at end of the list
|
|
*/
|
|
if (current->next == NULL)
|
|
{
|
|
newBigBlock = BIGBLOCKFILE_CreateBlock(index);
|
|
|
|
if (newBigBlock != NULL)
|
|
{
|
|
newBigBlock->next = NULL;
|
|
current->next = newBigBlock;
|
|
}
|
|
|
|
return newBigBlock;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_RemoveBlock [PRIVATE]
|
|
*
|
|
* Removes the specified block from the blocks list.
|
|
*/
|
|
static void BIGBLOCKFILE_RemoveBlock(
|
|
LPBIGBLOCKFILE This,
|
|
ULONG index)
|
|
{
|
|
BigBlock *current = This->headblock;
|
|
|
|
/*
|
|
* empty list
|
|
*/
|
|
if (current == NULL)
|
|
return;
|
|
|
|
/*
|
|
*special case: removing head of list
|
|
*/
|
|
if (current->index == index)
|
|
{
|
|
/*
|
|
* set new head free the old one
|
|
*/
|
|
This->headblock = current->next;
|
|
HeapFree(GetProcessHeap(), 0, current);
|
|
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* iterate through rest of the list
|
|
*/
|
|
while (current->next != NULL)
|
|
{
|
|
if (current->next->index == index) /* found it */
|
|
{
|
|
/*
|
|
* unlink the block and free the block
|
|
*/
|
|
current->next = current->next->next;
|
|
HeapFree(GetProcessHeap(), 0, current->next);
|
|
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
/* next node
|
|
*/
|
|
current = current->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_GetBigBlockFromPointer [PRIVATE]
|
|
*
|
|
* Given a block pointer, this will return the corresponding block
|
|
* from the blocks list.
|
|
*/
|
|
static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(
|
|
LPBIGBLOCKFILE This,
|
|
void* pBlock)
|
|
{
|
|
BigBlock *current = This->headblock;
|
|
|
|
while (current != NULL)
|
|
{
|
|
if (current->lpBlock == pBlock)
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
current = current->next;
|
|
}
|
|
|
|
return current;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_GetMappedView [PRIVATE]
|
|
*
|
|
* Gets the page requested if it is already mapped.
|
|
* If it's not already mapped, this method will map it
|
|
*/
|
|
static void * BIGBLOCKFILE_GetMappedView(
|
|
LPBIGBLOCKFILE This,
|
|
DWORD pagenum,
|
|
DWORD desired_access)
|
|
{
|
|
MappedPage* current = This->maplisthead;
|
|
ULONG count = 1;
|
|
BOOL found = FALSE;
|
|
|
|
assert(This->maplisthead != NULL);
|
|
|
|
/*
|
|
* Search for the page in the list.
|
|
*/
|
|
while ((found == FALSE) && (current->next != NULL))
|
|
{
|
|
if (current->next->number == pagenum)
|
|
{
|
|
found = TRUE;
|
|
|
|
/*
|
|
* If it's not already at the head of the list
|
|
* move it there.
|
|
*/
|
|
if (current != This->maplisthead)
|
|
{
|
|
MappedPage* temp = current->next;
|
|
|
|
current->next = current->next->next;
|
|
|
|
temp->next = This->maplisthead->next;
|
|
This->maplisthead->next = temp;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The list is full and we haven't found it.
|
|
* Free the last element of the list because we'll add a new
|
|
* one at the head.
|
|
*/
|
|
if ((found == FALSE) &&
|
|
(count >= NUMBER_OF_MAPPED_PAGES) &&
|
|
(current->next != NULL))
|
|
{
|
|
UnmapViewOfFile(current->next->lpBytes);
|
|
|
|
HeapFree(GetProcessHeap(), 0, current->next);
|
|
current->next = NULL;
|
|
}
|
|
|
|
if (current->next != NULL)
|
|
current = current->next;
|
|
|
|
count++;
|
|
}
|
|
|
|
/*
|
|
* Add the page at the head of the list.
|
|
*/
|
|
if (found == FALSE)
|
|
{
|
|
MappedPage* newMappedPage;
|
|
DWORD numBytesToMap;
|
|
DWORD hioffset = 0;
|
|
DWORD lowoffset = PAGE_SIZE * pagenum;
|
|
|
|
newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
|
|
|
|
if (newMappedPage == NULL)
|
|
return NULL;
|
|
|
|
newMappedPage->number = pagenum;
|
|
newMappedPage->ref = 0;
|
|
|
|
newMappedPage->next = This->maplisthead->next;
|
|
This->maplisthead->next = newMappedPage;
|
|
|
|
if (((pagenum + 1) * PAGE_SIZE) > This->filesize.LowPart)
|
|
numBytesToMap = This->filesize.LowPart - (pagenum * PAGE_SIZE);
|
|
else
|
|
numBytesToMap = PAGE_SIZE;
|
|
|
|
if (This->flProtect == PAGE_READONLY)
|
|
desired_access = FILE_MAP_READ;
|
|
else
|
|
desired_access = FILE_MAP_WRITE;
|
|
|
|
newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
|
|
desired_access,
|
|
hioffset,
|
|
lowoffset,
|
|
numBytesToMap);
|
|
}
|
|
|
|
/*
|
|
* The page we want should now be at the head of the list.
|
|
*/
|
|
assert(This->maplisthead->next != NULL);
|
|
|
|
current = This->maplisthead->next;
|
|
current->ref++;
|
|
|
|
return current->lpBytes;
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_ReleaseMappedPage [PRIVATE]
|
|
*
|
|
* Decrements the reference count of the mapped page.
|
|
*/
|
|
static void BIGBLOCKFILE_ReleaseMappedPage(
|
|
LPBIGBLOCKFILE This,
|
|
DWORD pagenum,
|
|
DWORD access)
|
|
{
|
|
MappedPage* previous = This->maplisthead;
|
|
MappedPage* current;
|
|
|
|
assert(This->maplisthead->next != NULL);
|
|
|
|
current = previous->next;
|
|
|
|
/* search for the page in the list
|
|
*/
|
|
while (current != NULL)
|
|
{
|
|
if (current->number == pagenum)
|
|
{
|
|
/* decrement the reference count
|
|
*/
|
|
current->ref--;
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
previous = current;
|
|
current = current->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
/******************************************************************************
|
|
* BIGBLOCKFILE_FreeAllMappedPages [PRIVATE]
|
|
*
|
|
* Unmap all currently mapped pages.
|
|
* Empty mapped pages list.
|
|
*/
|
|
static void BIGBLOCKFILE_FreeAllMappedPages(
|
|
LPBIGBLOCKFILE This)
|
|
{
|
|
MappedPage * current = This->maplisthead->next;
|
|
|
|
while (current != NULL)
|
|
{
|
|
/* Unmap views.
|
|
*/
|
|
UnmapViewOfFile(current->lpBytes);
|
|
|
|
/* Free the nodes.
|
|
*/
|
|
This->maplisthead->next = current->next;
|
|
HeapFree(GetProcessHeap(), 0, current);
|
|
|
|
current = This->maplisthead->next;
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* BIGBLOCKFILE_GetProtectMode
|
|
*
|
|
* This function will return a protection mode flag for a file-mapping object
|
|
* from the open flags of a file.
|
|
*/
|
|
static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags)
|
|
{
|
|
DWORD flProtect = PAGE_READONLY;
|
|
BOOL bSTGM_WRITE = ((openFlags & STGM_WRITE) == STGM_WRITE);
|
|
BOOL bSTGM_READWRITE = ((openFlags & STGM_READWRITE) == STGM_READWRITE);
|
|
BOOL bSTGM_READ = ! (bSTGM_WRITE || bSTGM_READWRITE);
|
|
|
|
if (bSTGM_READ)
|
|
flProtect = PAGE_READONLY;
|
|
|
|
if ((bSTGM_WRITE) || (bSTGM_READWRITE))
|
|
flProtect = PAGE_READWRITE;
|
|
|
|
return flProtect;
|
|
}
|
|
|
|
|