wined3d: Move setting the draw buffer to a separate function.
[wine] / 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 WINAPI 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 WINAPI 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 }