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