git.oblomov.eu Git - wine/blob - dlls/ole32/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  * This library is free software; you can redistribute it and/or
  20  * modify it under the terms of the GNU Lesser General Public
  21  * License as published by the Free Software Foundation; either
  22  * version 2.1 of the License, or (at your option) any later version.
  23  *
  24  * This library is distributed in the hope that it will be useful,
  25  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  27  * Lesser General Public License for more details.
  28  *
  29  * You should have received a copy of the GNU Lesser General Public
  30  * License along with this library; if not, write to the Free Software
  31  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  32  */
  33
  34 #include <assert.h>
  35 #include <stdlib.h>
  36 #include <stdarg.h>
  37 #include <stdio.h>
  38 #include <string.h>
  39 #include <limits.h>
  40
  41 #define COBJMACROS
  42 #define NONAMELESSUNION
  43 #define NONAMELESSSTRUCT
  44
  45 #include "windef.h"
  46 #include "winbase.h"
  47 #include "winuser.h"
  48 #include "winerror.h"
  49 #include "objbase.h"
  50 #include "ole2.h"
  51
  52 #include "storage32.h"
  53
  54 #include "wine/debug.h"
  55
  56 WINE_DEFAULT_DEBUG_CHANNEL(storage);
  57
  58 /***********************************************************
  59  * Data structures used internally by the BigBlockFile
  60  * class.
  61  */
  62
  63 /* We map in PAGE_SIZE-sized chunks. Must be a multiple of 4096. */
  64 #define PAGE_SIZE       131072
  65
  66 #define BLOCKS_PER_PAGE (PAGE_SIZE / BIG_BLOCK_SIZE)
  67
  68 /* We keep a list of recently-discarded pages. This controls the
  69  * size of that list. */
  70 #define MAX_VICTIM_PAGES 16
  71
  72 /* This structure provides one bit for each block in a page.
  73  * Use BIGBLOCKFILE_{Test,Set,Clear}Bit to manipulate it. */
  74 typedef struct
  75 {
  76     unsigned int bits[BLOCKS_PER_PAGE / (CHAR_BIT * sizeof(unsigned int))];
  77 } BlockBits;
  78
  79 /***
  80  * This structure identifies the paged that are mapped
  81  * from the file and their position in memory. It is
  82  * also used to hold a reference count to those pages.
  83  *
  84  * page_index identifies which PAGE_SIZE chunk from the
  85  * file this mapping represents. (The mappings are always
  86  * PAGE_SIZE-aligned.)
  87  */
  88 struct MappedPage
  89 {
  90     MappedPage *next;
  91     MappedPage *prev;
  92
  93     DWORD  page_index;
  94     DWORD  mapped_bytes;
  95     LPVOID lpBytes;
  96     LONG   refcnt;
  97
  98     BlockBits readable_blocks;
  99     BlockBits writable_blocks;
 100 };
 101
 102 /***********************************************************
 103  * Prototypes for private methods
 104  */
 105 static void*     BIGBLOCKFILE_GetMappedView(LPBIGBLOCKFILE This,
 106                                             DWORD          page_index);
 107 static void      BIGBLOCKFILE_ReleaseMappedPage(LPBIGBLOCKFILE This,
 108                                                 MappedPage *page);
 109 static void      BIGBLOCKFILE_FreeAllMappedPages(LPBIGBLOCKFILE This);
 110 static void      BIGBLOCKFILE_UnmapAllMappedPages(LPBIGBLOCKFILE This);
 111 static void      BIGBLOCKFILE_RemapAllMappedPages(LPBIGBLOCKFILE This);
 112 static MappedPage* BIGBLOCKFILE_CreatePage(LPBIGBLOCKFILE This,
 113                                            ULONG page_index);
 114 static DWORD     BIGBLOCKFILE_GetProtectMode(DWORD openFlags);
 115 static BOOL      BIGBLOCKFILE_FileInit(LPBIGBLOCKFILE This, HANDLE hFile);
 116 static BOOL      BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt);
 117 static void      BIGBLOCKFILE_DeleteList(LPBIGBLOCKFILE This, MappedPage *list);
 118
 119 /* Note that this evaluates a and b multiple times, so don't
 120  * pass expressions with side effects. */
 121 #define ROUND_UP(a, b) ((((a) + (b) - 1)/(b))*(b))
 122
 123 /***********************************************************
 124  * Blockbits functions.
 125  */
 126 static inline BOOL BIGBLOCKFILE_TestBit(const BlockBits *bb,
 127                                         unsigned int index)
 128 {
 129     unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
 130     unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
 131
 132     return bb->bits[array_index] & (1 << bit_index);
 133 }
 134
 135 static inline void BIGBLOCKFILE_SetBit(BlockBits *bb, unsigned int index)
 136 {
 137     unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
 138     unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
 139
 140     bb->bits[array_index] |= (1 << bit_index);
 141 }
 142
 143 static inline void BIGBLOCKFILE_ClearBit(BlockBits *bb, unsigned int index)
 144 {
 145     unsigned int array_index = index / (CHAR_BIT * sizeof(unsigned int));
 146     unsigned int bit_index = index % (CHAR_BIT * sizeof(unsigned int));
 147
 148     bb->bits[array_index] &= ~(1 << bit_index);
 149 }
 150
 151 static inline void BIGBLOCKFILE_Zero(BlockBits *bb)
 152 {
 153     memset(bb->bits, 0, sizeof(bb->bits));
 154 }
 155
 156 /******************************************************************************
 157  *      BIGBLOCKFILE_Construct
 158  *
 159  * Construct a big block file. Create the file mapping object.
 160  * Create the read only mapped pages list, the writable mapped page list
 161  * and the blocks in use list.
 162  */
 163 BigBlockFile * BIGBLOCKFILE_Construct(
 164   HANDLE   hFile,
 165   ILockBytes* pLkByt,
 166   DWORD    openFlags,
 167   ULONG    blocksize,
 168   BOOL     fileBased)
 169 {
 170   LPBIGBLOCKFILE This;
 171
 172   This = HeapAlloc(GetProcessHeap(), 0, sizeof(BigBlockFile));
 173
 174   if (This == NULL)
 175     return NULL;
 176
 177   This->fileBased = fileBased;
 178
 179   This->flProtect = BIGBLOCKFILE_GetProtectMode(openFlags);
 180
 181   This->blocksize = blocksize;
 182
 183   This->maplist = NULL;
 184   This->victimhead = NULL;
 185   This->victimtail = NULL;
 186   This->num_victim_pages = 0;
 187
 188   if (This->fileBased)
 189   {
 190     if (!BIGBLOCKFILE_FileInit(This, hFile))
 191     {
 192       HeapFree(GetProcessHeap(), 0, This);
 193       return NULL;
 194     }
 195   }
 196   else
 197   {
 198     if (!BIGBLOCKFILE_MemInit(This, pLkByt))
 199     {
 200       HeapFree(GetProcessHeap(), 0, This);
 201       return NULL;
 202     }
 203   }
 204
 205   return This;
 206 }
 207
 208 /******************************************************************************
 209  *      BIGBLOCKFILE_FileInit
 210  *
 211  * Initialize a big block object supported by a file.
 212  */
 213 static BOOL BIGBLOCKFILE_FileInit(LPBIGBLOCKFILE This, HANDLE hFile)
 214 {
 215   This->pLkbyt     = NULL;
 216   This->hbytearray = 0;
 217   This->pbytearray = NULL;
 218
 219   This->hfile = hFile;
 220
 221   if (This->hfile == INVALID_HANDLE_VALUE)
 222     return FALSE;
 223
 224   This->filesize.u.LowPart = GetFileSize(This->hfile,
 225                                          &This->filesize.u.HighPart);
 226
 227   if( This->filesize.u.LowPart || This->filesize.u.HighPart )
 228   {
 229     /* create the file mapping object
 230      */
 231     This->hfilemap = CreateFileMappingA(This->hfile,
 232                                         NULL,
 233                                         This->flProtect,
 234                                         0, 0,
 235                                         NULL);
 236
 237     if (!This->hfilemap)
 238     {
 239       CloseHandle(This->hfile);
 240       return FALSE;
 241     }
 242   }
 243   else
 244     This->hfilemap = NULL;
 245
 246   This->maplist = NULL;
 247
 248   TRACE("file len %u\n", This->filesize.u.LowPart);
 249
 250   return TRUE;
 251 }
 252
 253 /******************************************************************************
 254  *      BIGBLOCKFILE_MemInit
 255  *
 256  * Initialize a big block object supported by an ILockBytes on HGLOABL.
 257  */
 258 static BOOL BIGBLOCKFILE_MemInit(LPBIGBLOCKFILE This, ILockBytes* plkbyt)
 259 {
 260   This->hfile       = 0;
 261   This->hfilemap    = 0;
 262
 263   /*
 264    * Retrieve the handle to the byte array from the LockByte object.
 265    */
 266   if (GetHGlobalFromILockBytes(plkbyt, &(This->hbytearray)) != S_OK)
 267   {
 268     FIXME("May not be an ILockBytes on HGLOBAL\n");
 269     return FALSE;
 270   }
 271
 272   This->pLkbyt = plkbyt;
 273
 274   /*
 275    * Increment the reference count of the ILockByte object since
 276    * we're keeping a reference to it.
 277    */
 278   ILockBytes_AddRef(This->pLkbyt);
 279
 280   This->filesize.u.LowPart = GlobalSize(This->hbytearray);
 281   This->filesize.u.HighPart = 0;
 282
 283   This->pbytearray = GlobalLock(This->hbytearray);
 284
 285   TRACE("mem on %p len %u\n", This->pbytearray, This->filesize.u.LowPart);
 286
 287   return TRUE;
 288 }
 289
 290 /******************************************************************************
 291  *      BIGBLOCKFILE_Destructor
 292  *
 293  * Destructor. Clean up, free memory.
 294  */
 295 void BIGBLOCKFILE_Destructor(
 296   LPBIGBLOCKFILE This)
 297 {
 298   BIGBLOCKFILE_FreeAllMappedPages(This);
 299
 300   if (This->fileBased)
 301   {
 302     CloseHandle(This->hfilemap);
 303     CloseHandle(This->hfile);
 304   }
 305   else
 306   {
 307     GlobalUnlock(This->hbytearray);
 308     ILockBytes_Release(This->pLkbyt);
 309   }
 310
 311   /* destroy this
 312    */
 313   HeapFree(GetProcessHeap(), 0, This);
 314 }
 315
 316 /******************************************************************************
 317  *      BIGBLOCKFILE_EnsureExists
 318  *
 319  * Grows the file if necessary to make sure the block is valid.
 320  */
 321 void BIGBLOCKFILE_EnsureExists(LPBIGBLOCKFILE This, ULONG index)
 322 {
 323   /*
 324    * block index starts at -1
 325    * translate to zero based index
 326    */
 327   if (index == 0xffffffff)
 328     index = 0;
 329   else
 330     index++;
 331
 332   /*
 333    * make sure that the block physically exists
 334    */
 335   if ((This->blocksize * (index + 1)) > This->filesize.u.LowPart)
 336   {
 337     ULARGE_INTEGER newSize;
 338
 339     newSize.u.HighPart = 0;
 340     newSize.u.LowPart = This->blocksize * (index + 1);
 341
 342     BIGBLOCKFILE_SetSize(This, newSize);
 343   }
 344 }
 345
 346 /******************************************************************************
 347  *      BIGBLOCKFILE_SetSize
 348  *
 349  * Sets the size of the file.
 350  *
 351  */
 352 void BIGBLOCKFILE_SetSize(LPBIGBLOCKFILE This, ULARGE_INTEGER newSize)
 353 {
 354   if (This->filesize.u.LowPart == newSize.u.LowPart)
 355     return;
 356
 357   TRACE("from %u to %u\n", This->filesize.u.LowPart, newSize.u.LowPart);
 358   /*
 359    * unmap all views, must be done before call to SetEndFile
 360    *
 361    * Just ditch the victim list because there is no guarantee we will need them
 362    * and it is not worth the performance hit to unmap and remap them all.
 363    */
 364   BIGBLOCKFILE_DeleteList(This, This->victimhead);
 365   This->victimhead = NULL;
 366   This->victimtail = NULL;
 367   This->num_victim_pages = 0;
 368
 369   BIGBLOCKFILE_UnmapAllMappedPages(This);
 370
 371   if (This->fileBased)
 372   {
 373     LARGE_INTEGER newpos;
 374
 375     newpos.QuadPart = newSize.QuadPart;
 376     if (SetFilePointerEx(This->hfile, newpos, NULL, FILE_BEGIN))
 377     {
 378         if( This->hfilemap ) CloseHandle(This->hfilemap);
 379
 380         SetEndOfFile(This->hfile);
 381
 382         /*
 383          * re-create the file mapping object
 384          */
 385         This->hfilemap = CreateFileMappingA(This->hfile,
 386                                             NULL,
 387                                             This->flProtect,
 388                                             0, 0,
 389                                             NULL);
 390     }
 391   }
 392   else
 393   {
 394     GlobalUnlock(This->hbytearray);
 395
 396     /*
 397      * Resize the byte array object.
 398      */
 399     ILockBytes_SetSize(This->pLkbyt, newSize);
 400
 401     /*
 402      * Re-acquire the handle, it may have changed.
 403      */
 404     GetHGlobalFromILockBytes(This->pLkbyt, &This->hbytearray);
 405     This->pbytearray = GlobalLock(This->hbytearray);
 406   }
 407
 408   This->filesize.u.LowPart = newSize.u.LowPart;
 409   This->filesize.u.HighPart = newSize.u.HighPart;
 410
 411   BIGBLOCKFILE_RemapAllMappedPages(This);
 412 }
 413
 414 /******************************************************************************
 415  *      BIGBLOCKFILE_FindPageInList      [PRIVATE]
 416  *
 417  */
 418 static MappedPage *BIGBLOCKFILE_FindPageInList(MappedPage *head,
 419                                                ULONG page_index)
 420 {
 421     for (; head != NULL; head = head->next)
 422     {
 423         if (head->page_index == page_index)
 424         {
 425             InterlockedIncrement(&head->refcnt);
 426             break;
 427         }
 428     }
 429
 430     return head;
 431
 432 }
 433
 434 static void BIGBLOCKFILE_UnlinkPage(MappedPage *page)
 435 {
 436     if (page->next) page->next->prev = page->prev;
 437     if (page->prev) page->prev->next = page->next;
 438 }
 439
 440 static void BIGBLOCKFILE_LinkHeadPage(MappedPage **head, MappedPage *page)
 441 {
 442     if (*head) (*head)->prev = page;
 443     page->next = *head;
 444     page->prev = NULL;
 445     *head = page;
 446 }
 447
 448 /******************************************************************************
 449  *      BIGBLOCKFILE_GetMappedView      [PRIVATE]
 450  *
 451  * Gets the page requested if it is already mapped.
 452  * If it's not already mapped, this method will map it
 453  */
 454 static void * BIGBLOCKFILE_GetMappedView(
 455   LPBIGBLOCKFILE This,
 456   DWORD          page_index)
 457 {
 458     MappedPage *page;
 459
 460     page = BIGBLOCKFILE_FindPageInList(This->maplist, page_index);
 461     if (!page)
 462     {
 463         page = BIGBLOCKFILE_FindPageInList(This->victimhead, page_index);
 464         if (page)
 465         {
 466             This->num_victim_pages--;
 467
 468             BIGBLOCKFILE_Zero(&page->readable_blocks);
 469             BIGBLOCKFILE_Zero(&page->writable_blocks);
 470         }
 471     }
 472
 473     if (page)
 474     {
 475         /* If the page is not already at the head of the list, move
 476          * it there. (Also moves pages from victim to main list.) */
 477         if (This->maplist != page)
 478         {
 479             if (This->victimhead == page) This->victimhead = page->next;
 480             if (This->victimtail == page) This->victimtail = page->prev;
 481
 482             BIGBLOCKFILE_UnlinkPage(page);
 483
 484             BIGBLOCKFILE_LinkHeadPage(&This->maplist, page);
 485         }
 486
 487         return page;
 488     }
 489
 490     page = BIGBLOCKFILE_CreatePage(This, page_index);
 491     if (!page) return NULL;
 492
 493     BIGBLOCKFILE_LinkHeadPage(&This->maplist, page);
 494
 495     return page;
 496 }
 497
 498 static BOOL BIGBLOCKFILE_MapPage(LPBIGBLOCKFILE This, MappedPage *page)
 499 {
 500     DWORD lowoffset = PAGE_SIZE * page->page_index;
 501
 502     if (This->fileBased)
 503     {
 504         DWORD numBytesToMap;
 505         DWORD desired_access;
 506
 507         if( !This->hfilemap )
 508             return FALSE;
 509
 510         if (lowoffset + PAGE_SIZE > This->filesize.u.LowPart)
 511             numBytesToMap = This->filesize.u.LowPart - lowoffset;
 512         else
 513             numBytesToMap = PAGE_SIZE;
 514
 515         if (This->flProtect == PAGE_READONLY)
 516             desired_access = FILE_MAP_READ;
 517         else
 518             desired_access = FILE_MAP_WRITE;
 519
 520         page->lpBytes = MapViewOfFile(This->hfilemap, desired_access, 0,
 521                                       lowoffset, numBytesToMap);
 522         page->mapped_bytes = numBytesToMap;
 523     }
 524     else
 525     {
 526         page->lpBytes = (LPBYTE)This->pbytearray + lowoffset;
 527         page->mapped_bytes = PAGE_SIZE;
 528     }
 529
 530     TRACE("mapped page %u to %p\n", page->page_index, page->lpBytes);
 531
 532     return page->lpBytes != NULL;
 533 }
 534
 535 static MappedPage *BIGBLOCKFILE_CreatePage(LPBIGBLOCKFILE This,
 536                                            ULONG page_index)
 537 {
 538     MappedPage *page;
 539
 540     page = HeapAlloc(GetProcessHeap(), 0, sizeof(MappedPage));
 541     if (page == NULL)
 542       return NULL;
 543
 544     page->page_index = page_index;
 545     page->refcnt = 1;
 546
 547     page->next = NULL;
 548     page->prev = NULL;
 549
 550     if (!BIGBLOCKFILE_MapPage(This, page))
 551     {
 552         HeapFree(GetProcessHeap(),0,page);
 553         return NULL;
 554     }
 555
 556     BIGBLOCKFILE_Zero(&page->readable_blocks);
 557     BIGBLOCKFILE_Zero(&page->writable_blocks);
 558
 559     return page;
 560 }
 561
 562 static void BIGBLOCKFILE_UnmapPage(LPBIGBLOCKFILE This, MappedPage *page)
 563 {
 564     TRACE("%d at %p\n", page->page_index, page->lpBytes);
 565     if (page->refcnt > 0)
 566         ERR("unmapping inuse page %p\n", page->lpBytes);
 567
 568     if (This->fileBased && page->lpBytes)
 569         UnmapViewOfFile(page->lpBytes);
 570
 571     page->lpBytes = NULL;
 572 }
 573
 574 static void BIGBLOCKFILE_DeletePage(LPBIGBLOCKFILE This, MappedPage *page)
 575 {
 576     BIGBLOCKFILE_UnmapPage(This, page);
 577
 578     HeapFree(GetProcessHeap(), 0, page);
 579 }
 580
 581 /******************************************************************************
 582  *      BIGBLOCKFILE_ReleaseMappedPage      [PRIVATE]
 583  *
 584  * Decrements the reference count of the mapped page.
 585  */
 586 static void BIGBLOCKFILE_ReleaseMappedPage(
 587   LPBIGBLOCKFILE This,
 588   MappedPage    *page)
 589 {
 590     assert(This != NULL);
 591     assert(page != NULL);
 592
 593     /* If the page is no longer refenced, move it to the victim list.
 594      * If the victim list is too long, kick somebody off. */
 595     if (!InterlockedDecrement(&page->refcnt))
 596     {
 597         if (This->maplist == page) This->maplist = page->next;
 598
 599         BIGBLOCKFILE_UnlinkPage(page);
 600
 601         if (MAX_VICTIM_PAGES > 0)
 602         {
 603             if (This->num_victim_pages >= MAX_VICTIM_PAGES)
 604             {
 605                 MappedPage *victim = This->victimtail;
 606                 if (victim)
 607                 {
 608                     This->victimtail = victim->prev;
 609                     if (This->victimhead == victim)
 610                         This->victimhead = victim->next;
 611
 612                     BIGBLOCKFILE_UnlinkPage(victim);
 613                     BIGBLOCKFILE_DeletePage(This, victim);
 614                 }
 615             }
 616             else This->num_victim_pages++;
 617
 618             BIGBLOCKFILE_LinkHeadPage(&This->victimhead, page);
 619             if (This->victimtail == NULL) This->victimtail = page;
 620         }
 621         else
 622             BIGBLOCKFILE_DeletePage(This, page);
 623     }
 624 }
 625
 626 static void BIGBLOCKFILE_DeleteList(LPBIGBLOCKFILE This, MappedPage *list)
 627 {
 628     while (list != NULL)
 629     {
 630         MappedPage *next = list->next;
 631
 632         BIGBLOCKFILE_DeletePage(This, list);
 633
 634         list = next;
 635     }
 636 }
 637
 638 /******************************************************************************
 639  *      BIGBLOCKFILE_FreeAllMappedPages     [PRIVATE]
 640  *
 641  * Unmap all currently mapped pages.
 642  * Empty mapped pages list.
 643  */
 644 static void BIGBLOCKFILE_FreeAllMappedPages(
 645   LPBIGBLOCKFILE This)
 646 {
 647     BIGBLOCKFILE_DeleteList(This, This->maplist);
 648     BIGBLOCKFILE_DeleteList(This, This->victimhead);
 649
 650     This->maplist = NULL;
 651     This->victimhead = NULL;
 652     This->victimtail = NULL;
 653     This->num_victim_pages = 0;
 654 }
 655
 656 static void BIGBLOCKFILE_UnmapList(LPBIGBLOCKFILE This, MappedPage *list)
 657 {
 658     for (; list != NULL; list = list->next)
 659     {
 660         BIGBLOCKFILE_UnmapPage(This, list);
 661     }
 662 }
 663
 664 static void BIGBLOCKFILE_UnmapAllMappedPages(LPBIGBLOCKFILE This)
 665 {
 666     BIGBLOCKFILE_UnmapList(This, This->maplist);
 667     BIGBLOCKFILE_UnmapList(This, This->victimhead);
 668 }
 669
 670 static void BIGBLOCKFILE_RemapList(LPBIGBLOCKFILE This, MappedPage *list)
 671 {
 672     while (list != NULL)
 673     {
 674         MappedPage *next = list->next;
 675
 676         if (list->page_index * PAGE_SIZE > This->filesize.u.LowPart)
 677         {
 678             TRACE("discarding %u\n", list->page_index);
 679
 680             /* page is entirely outside of the file, delete it */
 681             BIGBLOCKFILE_UnlinkPage(list);
 682             BIGBLOCKFILE_DeletePage(This, list);
 683         }
 684         else
 685         {
 686             /* otherwise, remap it */
 687             BIGBLOCKFILE_MapPage(This, list);
 688         }
 689
 690         list = next;
 691     }
 692 }
 693
 694 static void BIGBLOCKFILE_RemapAllMappedPages(LPBIGBLOCKFILE This)
 695 {
 696     BIGBLOCKFILE_RemapList(This, This->maplist);
 697     BIGBLOCKFILE_RemapList(This, This->victimhead);
 698 }
 699
 700 /****************************************************************************
 701  *      BIGBLOCKFILE_GetProtectMode
 702  *
 703  * This function will return a protection mode flag for a file-mapping object
 704  * from the open flags of a file.
 705  */
 706 static DWORD BIGBLOCKFILE_GetProtectMode(DWORD openFlags)
 707 {
 708     switch(STGM_ACCESS_MODE(openFlags))
 709     {
 710     case STGM_WRITE:
 711     case STGM_READWRITE:
 712         return PAGE_READWRITE;
 713     }
 714     return PAGE_READONLY;
 715 }
 716
 717
 718 /* ILockByte Interfaces */
 719
 720 /******************************************************************************
 721  * This method is part of the ILockBytes interface.
 722  *
 723  * It reads a block of information from the byte array at the specified
 724  * offset.
 725  *
 726  * See the documentation of ILockBytes for more info.
 727  */
 728 static HRESULT ImplBIGBLOCKFILE_ReadAt(
 729       BigBlockFile* const This,
 730       ULARGE_INTEGER ulOffset,  /* [in] */
 731       void*          pv,        /* [length_is][size_is][out] */
 732       ULONG          cb,        /* [in] */
 733       ULONG*         pcbRead)   /* [out] */
 734 {
 735     ULONG first_page = ulOffset.u.LowPart / PAGE_SIZE;
 736     ULONG offset_in_page = ulOffset.u.LowPart % PAGE_SIZE;
 737     ULONG bytes_left = cb;
 738     ULONG page_index = first_page;
 739     ULONG bytes_from_page;
 740     LPVOID writePtr = pv;
 741
 742     HRESULT rc = S_OK;
 743
 744     TRACE("(%p)-> %i %p %i %p\n",This, ulOffset.u.LowPart, pv, cb, pcbRead);
 745
 746     /* verify a sane environment */
 747     if (!This) return E_FAIL;
 748
 749     if (offset_in_page + bytes_left > PAGE_SIZE)
 750         bytes_from_page = PAGE_SIZE - offset_in_page;
 751     else
 752         bytes_from_page = bytes_left;
 753
 754     if (pcbRead)
 755         *pcbRead = 0;
 756
 757     while (bytes_left)
 758     {
 759         LPBYTE readPtr;
 760         BOOL eof = FALSE;
 761         MappedPage *page = BIGBLOCKFILE_GetMappedView(This, page_index);
 762
 763         if (!page || !page->lpBytes)
 764         {
 765             rc = STG_E_READFAULT;
 766             break;
 767         }
 768
 769         TRACE("page %i,  offset %u, bytes_from_page %u, bytes_left %u\n",
 770             page->page_index, offset_in_page, bytes_from_page, bytes_left);
 771
 772         if (page->mapped_bytes < bytes_from_page)
 773         {
 774             eof = TRUE;
 775             bytes_from_page = page->mapped_bytes;
 776         }
 777
 778         readPtr = (BYTE*)page->lpBytes + offset_in_page;
 779         memcpy(writePtr,readPtr,bytes_from_page);
 780         BIGBLOCKFILE_ReleaseMappedPage(This, page);
 781
 782         if (pcbRead)
 783             *pcbRead += bytes_from_page;
 784         bytes_left -= bytes_from_page;
 785
 786         if (bytes_left && !eof)
 787         {
 788             writePtr = (LPBYTE)writePtr + bytes_from_page;
 789             page_index ++;
 790             offset_in_page = 0;
 791             if (bytes_left > PAGE_SIZE)
 792                 bytes_from_page = PAGE_SIZE;
 793             else
 794                 bytes_from_page = bytes_left;
 795         }
 796         if (eof)
 797         {
 798             rc = STG_E_READFAULT;
 799             break;
 800         }
 801     }
 802
 803     TRACE("finished\n");
 804     return rc;
 805 }
 806
 807 /******************************************************************************
 808  * This method is part of the ILockBytes interface.
 809  *
 810  * It writes the specified bytes at the specified offset.
 811  * position. If the file is too small, it will be resized.
 812  *
 813  * See the documentation of ILockBytes for more info.
 814  */
 815 static HRESULT ImplBIGBLOCKFILE_WriteAt(
 816       BigBlockFile* const This,
 817       ULARGE_INTEGER ulOffset,    /* [in] */
 818       const void*    pv,          /* [size_is][in] */
 819       ULONG          cb,          /* [in] */
 820       ULONG*         pcbWritten)  /* [out] */
 821 {
 822     ULONG size_needed = ulOffset.u.LowPart + cb;
 823     ULONG first_page = ulOffset.u.LowPart / PAGE_SIZE;
 824     ULONG offset_in_page = ulOffset.u.LowPart % PAGE_SIZE;
 825     ULONG bytes_left = cb;
 826     ULONG page_index = first_page;
 827     ULONG bytes_to_page;
 828     LPCVOID readPtr = pv;
 829
 830     HRESULT rc = S_OK;
 831
 832     TRACE("(%p)-> %i %p %i %p\n",This, ulOffset.u.LowPart, pv, cb, pcbWritten);
 833
 834     /* verify a sane environment */
 835     if (!This) return E_FAIL;
 836
 837     if (This->flProtect != PAGE_READWRITE)
 838         return STG_E_ACCESSDENIED;
 839
 840     if (size_needed > This->filesize.u.LowPart)
 841     {
 842         ULARGE_INTEGER newSize;
 843         newSize.u.HighPart = 0;
 844         newSize.u.LowPart = size_needed;
 845         BIGBLOCKFILE_SetSize(This, newSize);
 846     }
 847
 848     if (offset_in_page + bytes_left > PAGE_SIZE)
 849         bytes_to_page = PAGE_SIZE - offset_in_page;
 850     else
 851         bytes_to_page = bytes_left;
 852
 853     if (pcbWritten)
 854         *pcbWritten = 0;
 855
 856     while (bytes_left)
 857     {
 858         LPBYTE writePtr;
 859         MappedPage *page = BIGBLOCKFILE_GetMappedView(This, page_index);
 860
 861         TRACE("page %i,  offset %u, bytes_to_page %u, bytes_left %u\n",
 862             page ? page->page_index : 0, offset_in_page, bytes_to_page, bytes_left);
 863
 864         if (!page)
 865         {
 866             ERR("Unable to get a page to write. This should never happen\n");
 867             rc = E_FAIL;
 868             break;
 869         }
 870
 871         if (page->mapped_bytes < bytes_to_page)
 872         {
 873             ERR("Not enough bytes mapped to the page. This should never happen\n");
 874             rc = E_FAIL;
 875             break;
 876         }
 877
 878         writePtr = (BYTE*)page->lpBytes + offset_in_page;
 879         memcpy(writePtr,readPtr,bytes_to_page);
 880         BIGBLOCKFILE_ReleaseMappedPage(This, page);
 881
 882         if (pcbWritten)
 883             *pcbWritten += bytes_to_page;
 884         bytes_left -= bytes_to_page;
 885
 886         if (bytes_left)
 887         {
 888             readPtr = (const BYTE *)readPtr + bytes_to_page;
 889             page_index ++;
 890             offset_in_page = 0;
 891             if (bytes_left > PAGE_SIZE)
 892                 bytes_to_page = PAGE_SIZE;
 893             else
 894                 bytes_to_page = bytes_left;
 895         }
 896     }
 897
 898     return rc;
 899 }
 900
 901
 902 HRESULT     BIGBLOCKFILE_ReadAt(LPBIGBLOCKFILE This, ULARGE_INTEGER offset,
 903                 void* buffer, ULONG size, ULONG* bytesRead)
 904 {
 905     if (This->fileBased)
 906         return ImplBIGBLOCKFILE_ReadAt(This,offset,buffer,size,bytesRead);
 907     else
 908         return ILockBytes_ReadAt(This->pLkbyt,offset,buffer,size,bytesRead);
 909 }
 910
 911 HRESULT    BIGBLOCKFILE_WriteAt(LPBIGBLOCKFILE This, ULARGE_INTEGER offset,
 912                 const void* buffer, ULONG size, ULONG* bytesRead)
 913 {
 914     if (This->fileBased)
 915         return ImplBIGBLOCKFILE_WriteAt(This,offset,buffer,size,bytesRead);
 916     else
 917         return ILockBytes_WriteAt(This->pLkbyt,offset,buffer,size,bytesRead);
 918 }