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