ole/stg_bigblockfile.c

   1 /******************************************************************************
   2  *
   3  * BigBlockFile
   4  *
   5  * This is the implementation of a file that consists of blocks of
   6  * a predetermined size.
   7  * This class is used in the Compound File implementation of the
   8  * IStorage and IStream interfaces. It provides the functionality
   9  * to read and write any blocks in the file as well as setting and
  10  * obtaining the size of the file.
  11  * The blocks are indexed sequentially from the start of the file
  12  * starting with -1.
  13  *
  14  * TODO:
  15  * - Support for a transacted mode
  16  *
  17  * Copyright 1999 Thuy Nguyen
  18  *
  19  */
  20
  21 #include <assert.h>
  22 #include <stdlib.h>
  23 #include <stdio.h>
  24 #include <string.h>
  25
  26 #include "windows.h"
  27 #include "winerror.h"
  28 #include "ole.h"
  29 #include "ole2.h"
  30 #include "wine/obj_base.h"
  31 #include "wine/obj_storage.h"
  32
  33 #include "storage32.h"
  34
  35 /***********************************************************
  36  * Data structures used internally by the BigBlockFile
  37  * class.
  38  */
  39
  40 /***
  41  * Itdentifies a single big block and the related
  42  * information
  43  */
  44 struct BigBlock
  45 {
  46   BigBlock * next;
  47   DWORD index;
  48   DWORD access_mode;
  49   LPVOID lpBlock;
  50 };
  51
  52 /***
  53  * This structure identifies the paged that are mapped
  54  * from the file and their position in memory. It is
  55  * also used to hold a reference count to those pages.
  56  */
  57 struct MappedPage
  58 {
  59   MappedPage * next;
  60   DWORD number;
  61   int ref;
  62   LPVOID lpBytes;
  63 };
  64
  65 #define BLOCKS_PER_PAGE 128
  66 #define PAGE_SIZE 65536
  67
  68 /***********************************************************
  69  * Prototypes for private methods
  70  */
  71 static void*     BIGBLOCKFILE_GetMappedView(LPBIGBLOCKFILE This,
  72                                             DWORD          pagenum,
  73                                             DWORD          desired_access);
  74 static void      BIGBLOCKFILE_ReleaseMappedPage(LPBIGBLOCKFILE This,
  75                                                 DWORD          pagenum,
  76                                                 DWORD          access);
  77 static void      BIGBLOCKFILE_FreeAllMappedPages(LPBIGBLOCKFILE This);
  78 static void*     BIGBLOCKFILE_GetBigBlockPointer(LPBIGBLOCKFILE This,
  79                                                  ULONG          index,
  80                                                  DWORD          desired_access);
  81 static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(LPBIGBLOCKFILE This,
  82                                                      void*          pBlock);
  83 static void      BIGBLOCKFILE_RemoveBlock(LPBIGBLOCKFILE This,
  84                                           ULONG          index);
  85 static BigBlock* BIGBLOCKFILE_AddBigBlock(LPBIGBLOCKFILE This,
  86                                           ULONG          index);
  87 static BigBlock* BIGBLOCKFILE_CreateBlock(ULONG index);
  88
  89 static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags);
  90
  91 /******************************************************************************
  92  *      BIGBLOCKFILE_Construct
  93  *
  94  * Construct a big block file. Create the file mapping object.
  95  * Create the read only mapped pages list, the writeable mapped page list
  96  * and the blocks in use list.
  97  */
  98 BigBlockFile * BIGBLOCKFILE_Construct(
  99   HANDLE hFile,
 100     DWORD    openFlags,
 101   ULONG    blocksize)
 102 {
 103   LPBIGBLOCKFILE This;
 104
 105   This = (LPBIGBLOCKFILE)HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlockFile));
 106
 107   if (This == NULL)
 108     return NULL;
 109
 110   This->hfile = hFile;
 111
 112   if (This->hfile == INVALID_HANDLE_VALUE)
 113   {
 114     HeapFree(GetProcessHeap(), 0, This);
 115     return NULL;
 116   }
 117
 118   This->flProtect = BIGBLOCKFILE_GetProtectMode(openFlags);
 119
 120   /* create the file mapping object
 121    */
 122   This->hfilemap = CreateFileMappingA(This->hfile,
 123                                         NULL,
 124                                         This->flProtect,
 125                                         0, 0,
 126                                         NULL);
 127
 128   if (This->hfilemap == NULL)
 129   {
 130     CloseHandle(This->hfile);
 131     HeapFree(GetProcessHeap(), 0, This);
 132     return NULL;
 133   }
 134
 135   /* initialize this
 136    */
 137   This->filesize.LowPart = GetFileSize(This->hfile, NULL);
 138   This->blocksize = blocksize;
 139
 140   /* create the read only mapped pages list
 141    */
 142   This->headmap_ro = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 143
 144   if (This->headmap_ro == NULL)
 145   {
 146     CloseHandle(This->hfilemap);
 147     CloseHandle(This->hfile);
 148     HeapFree(GetProcessHeap(), 0, This);
 149     return NULL;
 150   }
 151
 152   This->headmap_ro->next = NULL;
 153
 154   /* create the writeable mapped pages list
 155    */
 156   This->headmap_w = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 157
 158   if (This->headmap_w == NULL)
 159   {
 160     CloseHandle(This->hfilemap);
 161     CloseHandle(This->hfile);
 162     HeapFree(GetProcessHeap(), 0, This->headmap_ro);
 163     HeapFree(GetProcessHeap(), 0, This);
 164     return NULL;
 165   }
 166
 167   This->headmap_w->next = NULL;
 168
 169   /* initialize the block list
 170    */
 171   This->headblock = NULL;
 172
 173   return This;
 174 }
 175
 176 /******************************************************************************
 177  *      BIGBLOCKFILE_Destructor
 178  *
 179  * Destructor. Clean up, free memory.
 180  */
 181 void BIGBLOCKFILE_Destructor(
 182   LPBIGBLOCKFILE This)
 183 {
 184   /* unmap all views and destroy the mapped page lists
 185    */
 186   BIGBLOCKFILE_FreeAllMappedPages(This);
 187   HeapFree(GetProcessHeap(), 0, This->headmap_ro);
 188   HeapFree(GetProcessHeap(), 0, This->headmap_w);
 189
 190   /* close all open handles
 191    */
 192   CloseHandle(This->hfilemap);
 193   CloseHandle(This->hfile);
 194
 195   /* destroy this
 196    */
 197   HeapFree(GetProcessHeap(), 0, This);
 198 }
 199
 200 /******************************************************************************
 201  *      BIGBLOCKFILE_GetROBigBlock
 202  *
 203  * Returns the specified block in read only mode.
 204  * Will return NULL if the block doesn't exists.
 205  */
 206 void* BIGBLOCKFILE_GetROBigBlock(
 207   LPBIGBLOCKFILE This,
 208   ULONG          index)
 209 {
 210   /*
 211    * block index starts at -1
 212    * translate to zero based index
 213    */
 214   if (index == 0xffffffff)
 215     index = 0;
 216   else
 217     index++;
 218
 219   /*
 220    * validate the block index
 221    *
 222    */
 223   if ((This->blocksize * (index + 1)) >
 224       (This->filesize.LowPart +
 225        (This->blocksize - (This->filesize.LowPart % This->blocksize))))
 226     return 0;
 227
 228   return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_READ);
 229 }
 230
 231 /******************************************************************************
 232  *      BIGBLOCKFILE_GetBigBlock
 233  *
 234  * Returns the specified block.
 235  * Will grow the file if necessary.
 236  */
 237 void* BIGBLOCKFILE_GetBigBlock(LPBIGBLOCKFILE This, ULONG index)
 238 {
 239   /*
 240    * block index starts at -1
 241    * translate to zero based index
 242    */
 243   if (index == 0xffffffff)
 244     index = 0;
 245   else
 246     index++;
 247
 248   /*
 249    * make sure that the block physically exists
 250    */
 251   if ((This->blocksize * (index + 1)) > This->filesize.LowPart)
 252   {
 253     ULARGE_INTEGER newSize;
 254
 255     newSize.HighPart = 0;
 256     newSize.LowPart = This->blocksize * (index + 1);
 257
 258     BIGBLOCKFILE_SetSize(This, newSize);
 259   }
 260
 261   return BIGBLOCKFILE_GetBigBlockPointer(This, index, FILE_MAP_WRITE);
 262 }
 263
 264 /******************************************************************************
 265  *      BIGBLOCKFILE_ReleaseBigBlock
 266  *
 267  * Releases the specified block.
 268  *
 269  */
 270 void BIGBLOCKFILE_ReleaseBigBlock(LPBIGBLOCKFILE This, void *pBlock)
 271 {
 272   DWORD page_num;
 273   BigBlock* theBigBlock;
 274
 275   if (pBlock == NULL)
 276     return;
 277
 278   /*
 279    * get the block from the block list
 280    */
 281   theBigBlock = BIGBLOCKFILE_GetBigBlockFromPointer(This, pBlock);
 282
 283   if (theBigBlock == NULL)
 284     return;
 285
 286   /*
 287    * find out which page this block is in
 288    */
 289   page_num = theBigBlock->index / BLOCKS_PER_PAGE;
 290
 291   /*
 292    * release this page
 293    */
 294   BIGBLOCKFILE_ReleaseMappedPage(This, page_num, theBigBlock->access_mode);
 295
 296   /*
 297    * remove block from list
 298    */
 299   BIGBLOCKFILE_RemoveBlock(This, theBigBlock->index);
 300 }
 301
 302 /******************************************************************************
 303  *      BIGBLOCKFILE_SetSize
 304  *
 305  * Sets the size of the file.
 306  *
 307  */
 308 void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
 309 {
 310   if (This->filesize.LowPart == newSize.LowPart)
 311     return;
 312
 313   /*
 314    * unmap all views, must be done before call to SetEndFile
 315    */
 316   BIGBLOCKFILE_FreeAllMappedPages(This);
 317
 318   /*
 319    * close file-mapping object, must be done before call to SetEndFile
 320    */
 321   CloseHandle(This->hfilemap);
 322   This->hfilemap = NULL;
 323
 324   /*
 325    * set the new end of file
 326    */
 327   SetFilePointer(This->hfile, newSize.LowPart, NULL, FILE_BEGIN);
 328   SetEndOfFile(This->hfile);
 329
 330   /*
 331    * re-create the file mapping object
 332    */
 333   This->hfilemap = CreateFileMappingA(This->hfile,
 334                                         NULL,
 335                                         This->flProtect,
 336                                         0, 0,
 337                                         NULL);
 338
 339   This->filesize.LowPart = newSize.LowPart;
 340   This->filesize.HighPart = newSize.HighPart;
 341 }
 342
 343 /******************************************************************************
 344  *      BIGBLOCKFILE_GetSize
 345  *
 346  * Returns the size of the file.
 347  *
 348  */
 349 ULARGE_INTEGER BIGBLOCKFILE_GetSize(LPBIGBLOCKFILE This)
 350 {
 351   return This->filesize;
 352 }
 353
 354 /******************************************************************************
 355  *      BIGBLOCKFILE_GetBigBlockPointer     [PRIVATE]
 356  *
 357  * Returns a pointer to the specified block.
 358  */
 359 static void* BIGBLOCKFILE_GetBigBlockPointer(
 360   LPBIGBLOCKFILE This,
 361   ULONG          index,
 362   DWORD          desired_access)
 363 {
 364   DWORD page_num, block_num;
 365   void * pBytes;
 366   BigBlock *aBigBlock;
 367
 368   /* get the big block from the list or add it to the list
 369    */
 370   aBigBlock = BIGBLOCKFILE_AddBigBlock(This, index);
 371
 372   if (aBigBlock == NULL)
 373     return NULL;
 374
 375   /* we already have an address for this block
 376    */
 377   if (aBigBlock->lpBlock != NULL)
 378   {
 379     /* make sure the desired access matches what we already have
 380      */
 381     if (aBigBlock->access_mode == desired_access)
 382       return aBigBlock->lpBlock;
 383     else
 384       return NULL;
 385   }
 386
 387   /*
 388    * else aBigBlock->lpBigBlock == NULL, it's a new block
 389    */
 390
 391   /* find out which page this block is in
 392    */
 393   page_num = index / BLOCKS_PER_PAGE;
 394
 395   /* offset of the block in the page
 396    */
 397   block_num = index % BLOCKS_PER_PAGE;
 398
 399   /* get a pointer to the first byte in the page
 400    */
 401   pBytes = BIGBLOCKFILE_GetMappedView(This, page_num, desired_access);
 402
 403   if (pBytes == NULL)
 404     return NULL;
 405
 406   /* initialize block
 407    */
 408   aBigBlock->lpBlock = ((BYTE*)pBytes + (block_num*This->blocksize));
 409   aBigBlock->access_mode = desired_access;
 410
 411   return aBigBlock->lpBlock;
 412 }
 413
 414 /******************************************************************************
 415  *      BIGBLOCKFILE_CreateBlock      [PRIVATE]
 416  *
 417  * Creates a node of the blocks list.
 418  */
 419 static BigBlock* BIGBLOCKFILE_CreateBlock(
 420   ULONG index)
 421 {
 422   BigBlock *newBigBlock;
 423
 424   /* create new list node
 425    */
 426   newBigBlock = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlock));
 427
 428   if (newBigBlock == NULL)
 429     return NULL;
 430
 431   /* initialize node
 432    */
 433   newBigBlock->index = index;
 434   newBigBlock->lpBlock = NULL;
 435
 436   return newBigBlock;
 437 }
 438
 439 /******************************************************************************
 440  *      BIGBLOCKFILE_AddBigBlock      [PRIVATE]
 441  *
 442  * Returns the specified block from the blocks list.
 443  * If the block is not found in the list, we will create it and add it to the
 444  * list.
 445  */
 446 static BigBlock* BIGBLOCKFILE_AddBigBlock(
 447   LPBIGBLOCKFILE This,
 448   ULONG          index)
 449 {
 450   BigBlock *current = This->headblock;
 451   BigBlock *newBigBlock;
 452
 453   if (current == NULL) /* empty list */
 454   {
 455     newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 456
 457     if (newBigBlock != NULL)
 458     {
 459       newBigBlock->next = NULL;
 460       This->headblock = newBigBlock;
 461     }
 462
 463     return newBigBlock;
 464   }
 465   else
 466   {
 467     /*
 468      * special handling for head of the list
 469      */
 470
 471     if (current->index == index) /* it's already here */
 472       return current;
 473     else if (current->index > index) /* insertion at head of the list */
 474     {
 475       newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 476
 477       if (newBigBlock != NULL)
 478       {
 479         newBigBlock->next = current;
 480         This->headblock = newBigBlock;
 481       }
 482
 483       return newBigBlock;
 484     }
 485   }
 486
 487   /* iterate through rest the list
 488    */
 489   while (current->next != NULL)
 490   {
 491     if (current->next->index == index) /* found it */
 492     {
 493       return current->next;
 494     }
 495     else if (current->next->index > index) /* it's not in the list */
 496     {
 497       newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 498
 499       if (newBigBlock != NULL)
 500       {
 501         newBigBlock->next = current->next;
 502         current->next = newBigBlock;
 503       }
 504
 505       return newBigBlock;
 506     }
 507     else
 508       current = current->next;
 509   }
 510
 511   /*
 512    * insertion at end of the list
 513    */
 514   if (current->next == NULL)
 515   {
 516     newBigBlock = BIGBLOCKFILE_CreateBlock(index);
 517
 518     if (newBigBlock != NULL)
 519     {
 520       newBigBlock->next = NULL;
 521       current->next = newBigBlock;
 522     }
 523
 524     return newBigBlock;
 525   }
 526
 527   return NULL;
 528 }
 529
 530 /******************************************************************************
 531  *      BIGBLOCKFILE_RemoveBlock      [PRIVATE]
 532  *
 533  * Removes the specified block from the blocks list.
 534  */
 535 static void BIGBLOCKFILE_RemoveBlock(
 536   LPBIGBLOCKFILE This,
 537   ULONG          index)
 538 {
 539   BigBlock *current = This->headblock;
 540
 541   /*
 542    * empty list
 543    */
 544   if (current == NULL)
 545     return;
 546
 547   /*
 548    *special case: removing head of list
 549    */
 550   if (current->index == index)
 551   {
 552     /*
 553      * set new head free the old one
 554      */
 555     This->headblock = current->next;
 556     HeapFree(GetProcessHeap(), 0, current);
 557
 558     return;
 559   }
 560
 561   /*
 562    * iterate through rest of the list
 563    */
 564   while (current->next != NULL)
 565   {
 566     if (current->next->index == index) /* found it */
 567     {
 568       /*
 569        * unlink the block and free the block
 570        */
 571       current->next = current->next->next;
 572       HeapFree(GetProcessHeap(), 0, current->next);
 573
 574       return;
 575     }
 576     else
 577     {
 578       /* next node
 579        */
 580       current = current->next;
 581     }
 582   }
 583 }
 584
 585 /******************************************************************************
 586  *      BIGBLOCKFILE_GetBigBlockFromPointer     [PRIVATE]
 587  *
 588  * Given a block pointer, this will return the corresponding block
 589  * from the blocks list.
 590  */
 591 static BigBlock* BIGBLOCKFILE_GetBigBlockFromPointer(
 592   LPBIGBLOCKFILE This,
 593   void*          pBlock)
 594 {
 595   BigBlock *current = This->headblock;
 596
 597   while (current != NULL)
 598   {
 599     if (current->lpBlock == pBlock)
 600     {
 601       break;
 602     }
 603     else
 604       current = current->next;
 605   }
 606
 607   return current;
 608 }
 609
 610 /******************************************************************************
 611  *      BIGBLOCKFILE_GetMappedView      [PRIVATE]
 612  *
 613  * Gets the page requested if it is already mapped.
 614  * If it's not already mapped, this method will map it
 615  */
 616 static void * BIGBLOCKFILE_GetMappedView(
 617   LPBIGBLOCKFILE This,
 618   DWORD          pagenum,
 619   DWORD          desired_access)
 620 {
 621   MappedPage * current;
 622   MappedPage * newMappedPage;
 623   DWORD hioffset, lowoffset;
 624   DWORD numBytesToMap;
 625
 626   /* use correct list
 627    */
 628   if (desired_access == FILE_MAP_READ)
 629     current = This->headmap_ro;
 630   else if (desired_access == FILE_MAP_WRITE)
 631     current = This->headmap_w;
 632   else
 633     return NULL;
 634
 635   hioffset = 0;
 636   lowoffset = PAGE_SIZE * pagenum;
 637
 638   while (current->next != NULL)
 639   {
 640     if (current->next->number == pagenum) /* page already mapped */
 641     {
 642       current->next->ref++;
 643       return current->next->lpBytes;
 644     }
 645     else if (current->next->number > pagenum) /* this page is not mapped yet */
 646     {
 647       /* allocate new MappedPage
 648        */
 649       newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 650
 651       if (newMappedPage == NULL)
 652         return NULL;
 653
 654       /* initialize the new MappedPage
 655        */
 656       newMappedPage->number = pagenum;
 657       newMappedPage->ref = 1;
 658
 659       newMappedPage->next = current->next;
 660       current->next = newMappedPage;
 661
 662       /* actually map the page
 663        */
 664       if (((pagenum + 1) * PAGE_SIZE) > This->filesize.LowPart)
 665         numBytesToMap = This->filesize.LowPart - (pagenum * PAGE_SIZE);
 666       else
 667         numBytesToMap = PAGE_SIZE;
 668
 669       newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
 670                                              desired_access,
 671                                              hioffset,
 672                                              lowoffset,
 673                                              numBytesToMap);
 674
 675       return newMappedPage->lpBytes;
 676     }
 677     else
 678       current = current->next;
 679   }
 680
 681   /* reached end of the list, this view is not mapped yet
 682    */
 683   if (current->next == NULL)
 684   {
 685     /* allocate new MappedPage
 686      */
 687     newMappedPage = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 688
 689     if (newMappedPage == NULL)
 690       return NULL;
 691
 692     /* initialize the new MappedPage
 693      */
 694     newMappedPage->number = pagenum;
 695     newMappedPage->ref = 1;
 696
 697     newMappedPage->next = NULL;
 698     current->next = newMappedPage;
 699
 700     /* actually map the page
 701      */
 702     if (((pagenum + 1) * PAGE_SIZE) > This->filesize.LowPart)
 703       numBytesToMap = This->filesize.LowPart - (pagenum * PAGE_SIZE);
 704     else
 705       numBytesToMap = PAGE_SIZE;
 706
 707     newMappedPage->lpBytes = MapViewOfFile(This->hfilemap,
 708                                            desired_access,
 709                                            hioffset,
 710                                            lowoffset,
 711                                            numBytesToMap);
 712
 713     return newMappedPage->lpBytes;
 714   }
 715
 716   return NULL;
 717 }
 718
 719 /******************************************************************************
 720  *      BIGBLOCKFILE_ReleaseMappedPage      [PRIVATE]
 721  *
 722  * Decrements the reference count of the mapped page.
 723  * If the page is not used anymore it will be unmapped.
 724  */
 725 static void BIGBLOCKFILE_ReleaseMappedPage(
 726   LPBIGBLOCKFILE This,
 727   DWORD          pagenum,
 728   DWORD          access)
 729 {
 730   MappedPage * previous;
 731   MappedPage * current;
 732
 733   /* use the list corresponding to the desired access mode
 734    */
 735   if (access == FILE_MAP_READ)
 736     previous = This->headmap_ro;
 737   else if (access == FILE_MAP_WRITE)
 738     previous = This->headmap_w;
 739   else
 740     return;
 741
 742   current = previous->next;
 743
 744   /* search for the page in the list
 745    */
 746   while (current != NULL)
 747   {
 748     if (current->number == pagenum)
 749     {
 750       /* decrement the reference count
 751        */
 752       current->ref--;
 753
 754       if (current->ref == 0)
 755       {
 756         /* this page is not used anymore, we can unmap it
 757          */
 758         UnmapViewOfFile(current->lpBytes);
 759
 760         previous->next = current->next;
 761         HeapFree(GetProcessHeap(), 0, current);
 762       }
 763
 764       return;
 765     }
 766     else
 767     {
 768       previous = current;
 769       current = current->next;
 770     }
 771   }
 772 }
 773
 774 /******************************************************************************
 775  *      BIGBLOCKFILE_FreeAllMappedPages     [PRIVATE]
 776  *
 777  * Unmap all currently mapped pages.
 778  * Empty both mapped pages lists.
 779  */
 780 static void BIGBLOCKFILE_FreeAllMappedPages(
 781   LPBIGBLOCKFILE This)
 782 {
 783   /*
 784    * start with the read only list
 785    */
 786   MappedPage * current = This->headmap_ro->next;
 787
 788   while (current != NULL)
 789   {
 790     /* unmap views
 791      */
 792     UnmapViewOfFile(current->lpBytes);
 793
 794     /* free the nodes
 795      */
 796     This->headmap_ro->next = current->next;
 797     HeapFree(GetProcessHeap(), 0, current);
 798
 799     current = This->headmap_ro->next;
 800   }
 801
 802   /*
 803    * then do the write list
 804    */
 805   current = This->headmap_w->next;
 806
 807   while (current != NULL)
 808   {
 809     /* unmap views
 810      */
 811     UnmapViewOfFile(current->lpBytes);
 812
 813     /* free the nodes
 814      */
 815     This->headmap_w->next = current->next;
 816     HeapFree(GetProcessHeap(), 0, current);
 817
 818     current = This->headmap_w->next;
 819   }
 820 }
 821
 822 /****************************************************************************
 823  *      BIGBLOCKFILE_GetProtectMode
 824  *
 825  * This function will return a protection mode flag for a file-mapping object
 826  * from the open flags of a file.
 827  */
 828 static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags)
 829 {
 830   DWORD flProtect        = PAGE_READONLY;
 831   BOOL bSTGM_WRITE     = ((openFlags & STGM_WRITE) == STGM_WRITE);
 832   BOOL bSTGM_READWRITE = ((openFlags & STGM_READWRITE) == STGM_READWRITE);
 833   BOOL bSTGM_READ      = ! (bSTGM_WRITE || bSTGM_READWRITE);
 834
 835   if (bSTGM_READ)
 836     flProtect = PAGE_READONLY;
 837
 838   if ((bSTGM_WRITE) || (bSTGM_READWRITE))
 839     flProtect = PAGE_READWRITE;
 840
 841   return flProtect;
 842 }
 843
 844