msi: Add more tests for the AppSearch action.
[wine] / dlls / kernel32 / heap.c
1 /*
2  * Win32 heap functions
3  *
4  * Copyright 1995, 1996 Alexandre Julliard
5  * Copyright 1996 Huw Davies
6  * Copyright 1998 Ulrich Weigand
7  *
8  * This library is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * This library is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with this library; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21  */
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <limits.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <string.h>
32 #include <sys/types.h>
33 #include <time.h>
34 #ifdef HAVE_SYS_PARAM_H
35 #include <sys/param.h>
36 #endif
37 #ifdef HAVE_SYS_SYSCTL_H
38 #include <sys/sysctl.h>
39 #endif
40 #ifdef HAVE_UNISTD_H
41 # include <unistd.h>
42 #endif
43
44 #ifdef sun
45 /* FIXME:  Unfortunately swapctl can't be used with largefile.... */
46 # undef _FILE_OFFSET_BITS
47 # define _FILE_OFFSET_BITS 32
48 # ifdef HAVE_SYS_RESOURCE_H
49 #  include <sys/resource.h>
50 # endif
51 # ifdef HAVE_SYS_STAT_H
52 #  include <sys/stat.h>
53 # endif
54 # include <sys/swap.h>
55 #endif
56
57
58 #include "windef.h"
59 #include "winbase.h"
60 #include "winerror.h"
61 #include "winnt.h"
62 #include "winternl.h"
63 #include "wine/exception.h"
64 #include "wine/debug.h"
65
66 WINE_DEFAULT_DEBUG_CHANNEL(heap);
67
68 /* address where we try to map the system heap */
69 #define SYSTEM_HEAP_BASE  ((void*)0x80000000)
70 #define SYSTEM_HEAP_SIZE  0x1000000   /* Default heap size = 16Mb */
71
72 static HANDLE systemHeap;   /* globally shared heap */
73
74
75 /***********************************************************************
76  *           HEAP_CreateSystemHeap
77  *
78  * Create the system heap.
79  */
80 static inline HANDLE HEAP_CreateSystemHeap(void)
81 {
82     int created;
83     void *base;
84     HANDLE map, event;
85
86     /* create the system heap event first */
87     event = CreateEventA( NULL, TRUE, FALSE, "__wine_system_heap_event" );
88
89     if (!(map = CreateFileMappingA( INVALID_HANDLE_VALUE, NULL, SEC_COMMIT | PAGE_READWRITE,
90                                     0, SYSTEM_HEAP_SIZE, "__wine_system_heap" ))) return 0;
91     created = (GetLastError() != ERROR_ALREADY_EXISTS);
92
93     if (!(base = MapViewOfFileEx( map, FILE_MAP_ALL_ACCESS, 0, 0, 0, SYSTEM_HEAP_BASE )))
94     {
95         /* pre-defined address not available */
96         ERR( "system heap base address %p not available\n", SYSTEM_HEAP_BASE );
97         return 0;
98     }
99
100     if (created)  /* newly created heap */
101     {
102         systemHeap = RtlCreateHeap( HEAP_SHARED, base, SYSTEM_HEAP_SIZE,
103                                     SYSTEM_HEAP_SIZE, NULL, NULL );
104         SetEvent( event );
105     }
106     else
107     {
108         /* wait for the heap to be initialized */
109         WaitForSingleObject( event, INFINITE );
110         systemHeap = base;
111     }
112     CloseHandle( map );
113     return systemHeap;
114 }
115
116
117 /***********************************************************************
118  *           HeapCreate   (KERNEL32.@)
119  *
120  * Create a heap object.
121  *
122  * RETURNS
123  *      Handle of heap: Success
124  *      NULL: Failure
125  */
126 HANDLE WINAPI HeapCreate(
127                 DWORD flags,       /* [in] Heap allocation flag */
128                 SIZE_T initialSize, /* [in] Initial heap size */
129                 SIZE_T maxSize      /* [in] Maximum heap size */
130 ) {
131     HANDLE ret;
132
133     if ( flags & HEAP_SHARED )
134     {
135         if (!systemHeap) HEAP_CreateSystemHeap();
136         else WARN( "Shared Heap requested, returning system heap.\n" );
137         ret = systemHeap;
138     }
139     else
140     {
141         ret = RtlCreateHeap( flags, NULL, maxSize, initialSize, NULL, NULL );
142         if (!ret) SetLastError( ERROR_NOT_ENOUGH_MEMORY );
143     }
144     return ret;
145 }
146
147
148 /***********************************************************************
149  *           HeapDestroy   (KERNEL32.@)
150  *
151  * Destroy a heap object.
152  *
153  * RETURNS
154  *      TRUE: Success
155  *      FALSE: Failure
156  */
157 BOOL WINAPI HeapDestroy( HANDLE heap /* [in] Handle of heap */ )
158 {
159     if (heap == systemHeap)
160     {
161         WARN( "attempt to destroy system heap, returning TRUE!\n" );
162         return TRUE;
163     }
164     if (!RtlDestroyHeap( heap )) return TRUE;
165     SetLastError( ERROR_INVALID_HANDLE );
166     return FALSE;
167 }
168
169
170 /***********************************************************************
171  *           HeapCompact   (KERNEL32.@)
172  */
173 SIZE_T WINAPI HeapCompact( HANDLE heap, DWORD flags )
174 {
175     return RtlCompactHeap( heap, flags );
176 }
177
178
179 /***********************************************************************
180  *           HeapValidate   (KERNEL32.@)
181  * Validates a specified heap.
182  *
183  * NOTES
184  *      Flags is ignored.
185  *
186  * RETURNS
187  *      TRUE: Success
188  *      FALSE: Failure
189  */
190 BOOL WINAPI HeapValidate(
191               HANDLE heap, /* [in] Handle to the heap */
192               DWORD flags,   /* [in] Bit flags that control access during operation */
193               LPCVOID block  /* [in] Optional pointer to memory block to validate */
194 ) {
195     return RtlValidateHeap( heap, flags, block );
196 }
197
198
199 /***********************************************************************
200  *           HeapWalk   (KERNEL32.@)
201  * Enumerates the memory blocks in a specified heap.
202  *
203  * TODO
204  *   - handling of PROCESS_HEAP_ENTRY_MOVEABLE and
205  *     PROCESS_HEAP_ENTRY_DDESHARE (needs heap.c support)
206  *
207  * RETURNS
208  *      TRUE: Success
209  *      FALSE: Failure
210  */
211 BOOL WINAPI HeapWalk(
212               HANDLE heap,               /* [in]  Handle to heap to enumerate */
213               LPPROCESS_HEAP_ENTRY entry /* [out] Pointer to structure of enumeration info */
214 ) {
215     NTSTATUS ret = RtlWalkHeap( heap, entry );
216     if (ret) SetLastError( RtlNtStatusToDosError(ret) );
217     return !ret;
218 }
219
220
221 /***********************************************************************
222  *           HeapLock   (KERNEL32.@)
223  * Attempts to acquire the critical section object for a specified heap.
224  *
225  * RETURNS
226  *      TRUE: Success
227  *      FALSE: Failure
228  */
229 BOOL WINAPI HeapLock(
230               HANDLE heap /* [in] Handle of heap to lock for exclusive access */
231 ) {
232     return RtlLockHeap( heap );
233 }
234
235
236 /***********************************************************************
237  *           HeapUnlock   (KERNEL32.@)
238  * Releases ownership of the critical section object.
239  *
240  * RETURNS
241  *      TRUE: Success
242  *      FALSE: Failure
243  */
244 BOOL WINAPI HeapUnlock(
245               HANDLE heap /* [in] Handle to the heap to unlock */
246 ) {
247     return RtlUnlockHeap( heap );
248 }
249
250
251 /***********************************************************************
252  *           GetProcessHeap    (KERNEL32.@)
253  */
254 HANDLE WINAPI GetProcessHeap(void)
255 {
256     return NtCurrentTeb()->Peb->ProcessHeap;
257 }
258
259
260 /***********************************************************************
261  *           GetProcessHeaps    (KERNEL32.@)
262  */
263 DWORD WINAPI GetProcessHeaps( DWORD count, HANDLE *heaps )
264 {
265     return RtlGetProcessHeaps( count, heaps );
266 }
267
268
269 /* These are needed so that we can call the functions from inside kernel itself */
270
271 /***********************************************************************
272  *           HeapAlloc    (KERNEL32.@)
273  */
274 LPVOID WINAPI HeapAlloc( HANDLE heap, DWORD flags, SIZE_T size )
275 {
276     return RtlAllocateHeap( heap, flags, size );
277 }
278
279 BOOL WINAPI HeapFree( HANDLE heap, DWORD flags, LPVOID ptr )
280 {
281     return RtlFreeHeap( heap, flags, ptr );
282 }
283
284 LPVOID WINAPI HeapReAlloc( HANDLE heap, DWORD flags, LPVOID ptr, SIZE_T size )
285 {
286     return RtlReAllocateHeap( heap, flags, ptr, size );
287 }
288
289 SIZE_T WINAPI HeapSize( HANDLE heap, DWORD flags, LPCVOID ptr )
290 {
291     return RtlSizeHeap( heap, flags, ptr );
292 }
293
294 BOOL WINAPI HeapSetInformation( HANDLE heap, HEAP_INFORMATION_CLASS infoclass, PVOID info, SIZE_T size)
295 {
296     FIXME("%p %d %p %ld\n", heap, infoclass, info, size );
297     return TRUE;
298 }
299
300 /*
301  * Win32 Global heap functions (GlobalXXX).
302  * These functions included in Win32 for compatibility with 16 bit Windows
303  * Especially the moveable blocks and handles are oldish.
304  * But the ability to directly allocate memory with GPTR and LPTR is widely
305  * used.
306  *
307  * The handle stuff looks horrible, but it's implemented almost like Win95
308  * does it.
309  *
310  */
311
312 #define MAGIC_GLOBAL_USED 0x5342
313 #define HANDLE_TO_INTERN(h)  ((PGLOBAL32_INTERN)(((char *)(h))-2))
314 #define INTERN_TO_HANDLE(i)  ((HGLOBAL) &((i)->Pointer))
315 #define POINTER_TO_HANDLE(p) (*(((const HGLOBAL *)(p))-2))
316 #define ISHANDLE(h)          (((ULONG_PTR)(h)&2)!=0)
317 #define ISPOINTER(h)         (((ULONG_PTR)(h)&2)==0)
318 /* align the storage needed for the HGLOBAL on an 8byte boundary thus
319  * GlobalAlloc/GlobalReAlloc'ing with GMEM_MOVEABLE of memory with
320  * size = 8*k, where k=1,2,3,... alloc's exactly the given size.
321  * The Minolta DiMAGE Image Viewer heavily relies on this, corrupting
322  * the output jpeg's > 1 MB if not */
323 #define HGLOBAL_STORAGE      8  /* sizeof(HGLOBAL)*2 */
324
325 #include "pshpack1.h"
326
327 typedef struct __GLOBAL32_INTERN
328 {
329    WORD         Magic;
330    LPVOID       Pointer;
331    BYTE         Flags;
332    BYTE         LockCount;
333 } GLOBAL32_INTERN, *PGLOBAL32_INTERN;
334
335 #include "poppack.h"
336
337 /***********************************************************************
338  *           GlobalAlloc   (KERNEL32.@)
339  *
340  * Allocate a global memory object.
341  *
342  * RETURNS
343  *      Handle: Success
344  *      NULL: Failure
345  */
346 HGLOBAL WINAPI GlobalAlloc(
347                  UINT flags, /* [in] Object allocation attributes */
348                  SIZE_T size /* [in] Number of bytes to allocate */
349 ) {
350    PGLOBAL32_INTERN     pintern;
351    DWORD                hpflags;
352    LPVOID               palloc;
353
354    if(flags&GMEM_ZEROINIT)
355       hpflags=HEAP_ZERO_MEMORY;
356    else
357       hpflags=0;
358
359    if((flags & GMEM_MOVEABLE)==0) /* POINTER */
360    {
361       palloc=HeapAlloc(GetProcessHeap(), hpflags, size);
362       TRACE( "(flags=%04x) returning %p\n",  flags, palloc );
363       return palloc;
364    }
365    else  /* HANDLE */
366    {
367       if (size > INT_MAX-HGLOBAL_STORAGE)
368       {
369           SetLastError(ERROR_OUTOFMEMORY);
370           return 0;
371       }
372
373       RtlLockHeap(GetProcessHeap());
374
375       pintern = HeapAlloc(GetProcessHeap(), 0, sizeof(GLOBAL32_INTERN));
376       if (pintern)
377       {
378           pintern->Magic = MAGIC_GLOBAL_USED;
379           pintern->Flags = flags >> 8;
380           pintern->LockCount = 0;
381
382           if (size)
383           {
384               palloc = HeapAlloc(GetProcessHeap(), hpflags, size+HGLOBAL_STORAGE);
385               if (!palloc)
386               {
387                   HeapFree(GetProcessHeap(), 0, pintern);
388                   pintern = NULL;
389               }
390               else
391               {
392                   *(HGLOBAL *)palloc = INTERN_TO_HANDLE(pintern);
393                   pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
394               }
395           }
396           else
397               pintern->Pointer = NULL;
398       }
399
400       RtlUnlockHeap(GetProcessHeap());
401       if (!pintern) return 0;
402       TRACE( "(flags=%04x) returning handle %p pointer %p\n",
403              flags, INTERN_TO_HANDLE(pintern), pintern->Pointer );
404       return INTERN_TO_HANDLE(pintern);
405    }
406 }
407
408
409 /***********************************************************************
410  *           GlobalLock   (KERNEL32.@)
411  *
412  * Lock a global memory object and return a pointer to first byte of the memory
413  *
414  * PARAMS
415  *  hmem [I] Handle of the global memory object
416  *
417  * RETURNS
418  *  Success: Pointer to first byte of the memory block
419  *  Failure: NULL
420  *
421  * NOTES
422  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
423  *
424  */
425 LPVOID WINAPI GlobalLock(HGLOBAL hmem)
426 {
427     PGLOBAL32_INTERN pintern;
428     LPVOID           palloc;
429
430     if (ISPOINTER(hmem))
431         return IsBadReadPtr(hmem, 1) ? NULL : hmem;
432
433     RtlLockHeap(GetProcessHeap());
434     __TRY
435     {
436         pintern = HANDLE_TO_INTERN(hmem);
437         if (pintern->Magic == MAGIC_GLOBAL_USED)
438         {
439             palloc = pintern->Pointer;
440             if (!pintern->Pointer)
441                 SetLastError(ERROR_DISCARDED);
442             else if (pintern->LockCount < GMEM_LOCKCOUNT)
443                 pintern->LockCount++;
444         }
445         else
446         {
447             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
448             palloc = NULL;
449             SetLastError(ERROR_INVALID_HANDLE);
450         }
451     }
452     __EXCEPT_PAGE_FAULT
453     {
454         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
455         palloc = NULL;
456         SetLastError(ERROR_INVALID_HANDLE);
457     }
458     __ENDTRY
459     RtlUnlockHeap(GetProcessHeap());
460     return palloc;
461 }
462
463
464 /***********************************************************************
465  *           GlobalUnlock   (KERNEL32.@)
466  *
467  * Unlock a global memory object.
468  *
469  * PARAMS
470  *  hmem [I] Handle of the global memory object
471  *
472  * RETURNS
473  *  Success: Object is still locked
474  *  Failure: FALSE (The Object is unlocked)
475  *
476  * NOTES
477  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
478  *
479  */
480 BOOL WINAPI GlobalUnlock(HGLOBAL hmem)
481 {
482     PGLOBAL32_INTERN pintern;
483     BOOL locked;
484
485     if (ISPOINTER(hmem)) return TRUE;
486
487     RtlLockHeap(GetProcessHeap());
488     __TRY
489     {
490         pintern=HANDLE_TO_INTERN(hmem);
491         if(pintern->Magic==MAGIC_GLOBAL_USED)
492         {
493             if(pintern->LockCount)
494             {
495                 pintern->LockCount--;
496                 locked = (pintern->LockCount != 0);
497                 if (!locked) SetLastError(NO_ERROR);
498             }
499             else
500             {
501                 WARN("%p not locked\n", hmem);
502                 SetLastError(ERROR_NOT_LOCKED);
503                 locked = FALSE;
504             }
505         }
506         else
507         {
508             WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
509             SetLastError(ERROR_INVALID_HANDLE);
510             locked=FALSE;
511         }
512     }
513     __EXCEPT_PAGE_FAULT
514     {
515         WARN("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
516         SetLastError( ERROR_INVALID_PARAMETER );
517         locked=FALSE;
518     }
519     __ENDTRY
520     RtlUnlockHeap(GetProcessHeap());
521     return locked;
522 }
523
524
525 /***********************************************************************
526  *           GlobalHandle   (KERNEL32.@)
527  *
528  * Get the handle associated with the pointer to a global memory block.
529  *
530  * RETURNS
531  *      Handle: Success
532  *      NULL: Failure
533  */
534 HGLOBAL WINAPI GlobalHandle(
535                  LPCVOID pmem /* [in] Pointer to global memory block */
536 ) {
537     HGLOBAL handle;
538     PGLOBAL32_INTERN  maybe_intern;
539     LPCVOID test;
540
541     if (!pmem)
542     {
543         SetLastError( ERROR_INVALID_PARAMETER );
544         return 0;
545     }
546
547     RtlLockHeap(GetProcessHeap());
548     __TRY
549     {
550         handle = 0;
551
552         /* note that if pmem is a pointer to a block allocated by        */
553         /* GlobalAlloc with GMEM_MOVEABLE then magic test in HeapValidate  */
554         /* will fail.                                                      */
555         if (ISPOINTER(pmem)) {
556             if (HeapValidate( GetProcessHeap(), 0, pmem )) {
557                 handle = (HGLOBAL)pmem;  /* valid fixed block */
558                 break;
559             }
560             handle = POINTER_TO_HANDLE(pmem);
561         } else
562             handle = (HGLOBAL)pmem;
563
564         /* Now test handle either passed in or retrieved from pointer */
565         maybe_intern = HANDLE_TO_INTERN( handle );
566         if (maybe_intern->Magic == MAGIC_GLOBAL_USED) {
567             test = maybe_intern->Pointer;
568             if (HeapValidate( GetProcessHeap(), 0, (const char *)test - HGLOBAL_STORAGE ) && /* obj(-handle) valid arena? */
569                 HeapValidate( GetProcessHeap(), 0, maybe_intern ))  /* intern valid arena? */
570                 break;  /* valid moveable block */
571         }
572         handle = 0;
573         SetLastError( ERROR_INVALID_HANDLE );
574     }
575     __EXCEPT_PAGE_FAULT
576     {
577         SetLastError( ERROR_INVALID_HANDLE );
578         handle = 0;
579     }
580     __ENDTRY
581     RtlUnlockHeap(GetProcessHeap());
582
583     return handle;
584 }
585
586
587 /***********************************************************************
588  *           GlobalReAlloc   (KERNEL32.@)
589  *
590  * Change the size or attributes of a global memory object.
591  *
592  * RETURNS
593  *      Handle: Success
594  *      NULL: Failure
595  */
596 HGLOBAL WINAPI GlobalReAlloc(
597                  HGLOBAL hmem, /* [in] Handle of global memory object */
598                  SIZE_T size,  /* [in] New size of block */
599                  UINT flags    /* [in] How to reallocate object */
600 ) {
601    LPVOID               palloc;
602    HGLOBAL            hnew;
603    PGLOBAL32_INTERN     pintern;
604    DWORD heap_flags = (flags & GMEM_ZEROINIT) ? HEAP_ZERO_MEMORY : 0;
605
606    hnew = 0;
607    RtlLockHeap(GetProcessHeap());
608    if(flags & GMEM_MODIFY) /* modify flags */
609    {
610       if( ISPOINTER(hmem) && (flags & GMEM_MOVEABLE))
611       {
612          /* make a fixed block moveable
613           * actually only NT is able to do this. But it's soo simple
614           */
615          if (hmem == 0)
616          {
617              WARN("GlobalReAlloc with null handle!\n");
618              SetLastError( ERROR_NOACCESS );
619              hnew = 0;
620          }
621          else
622          {
623              size = HeapSize(GetProcessHeap(), 0, hmem);
624              hnew = GlobalAlloc(flags, size);
625              palloc = GlobalLock(hnew);
626              memcpy(palloc, hmem, size);
627              GlobalUnlock(hnew);
628              GlobalFree(hmem);
629          }
630       }
631       else if( ISPOINTER(hmem) &&(flags & GMEM_DISCARDABLE))
632       {
633          /* change the flags to make our block "discardable" */
634          pintern=HANDLE_TO_INTERN(hmem);
635          pintern->Flags = pintern->Flags | (GMEM_DISCARDABLE >> 8);
636          hnew=hmem;
637       }
638       else
639       {
640          SetLastError(ERROR_INVALID_PARAMETER);
641          hnew = 0;
642       }
643    }
644    else
645    {
646       if(ISPOINTER(hmem))
647       {
648          /* reallocate fixed memory */
649          hnew=HeapReAlloc(GetProcessHeap(), heap_flags, hmem, size);
650       }
651       else
652       {
653          /* reallocate a moveable block */
654          pintern=HANDLE_TO_INTERN(hmem);
655
656 #if 0
657 /* Apparently Windows doesn't care whether the handle is locked at this point */
658 /* See also the same comment in GlobalFree() */
659          if(pintern->LockCount>1) {
660             ERR("handle 0x%08lx is still locked, cannot realloc!\n",(DWORD)hmem);
661             SetLastError(ERROR_INVALID_HANDLE);
662          } else
663 #endif
664          if(size!=0)
665          {
666             hnew=hmem;
667             if(pintern->Pointer)
668             {
669                if(size > INT_MAX-HGLOBAL_STORAGE)
670                {
671                    SetLastError(ERROR_OUTOFMEMORY);
672                    hnew = 0;
673                }
674                else if((palloc = HeapReAlloc(GetProcessHeap(), heap_flags,
675                                    (char *) pintern->Pointer-HGLOBAL_STORAGE,
676                                    size+HGLOBAL_STORAGE)) == NULL)
677                    hnew = 0; /* Block still valid */
678                else
679                    pintern->Pointer = (char *)palloc+HGLOBAL_STORAGE;
680             }
681             else
682             {
683                 if(size > INT_MAX-HGLOBAL_STORAGE)
684                 {
685                     SetLastError(ERROR_OUTOFMEMORY);
686                     hnew = 0;
687                 }
688                 else if((palloc=HeapAlloc(GetProcessHeap(), heap_flags, size+HGLOBAL_STORAGE))
689                    == NULL)
690                     hnew = 0;
691                 else
692                 {
693                     *(HGLOBAL *)palloc = hmem;
694                     pintern->Pointer = (char *)palloc + HGLOBAL_STORAGE;
695                 }
696             }
697          }
698          else
699          {
700             if (pintern->LockCount == 0)
701             {
702                 if(pintern->Pointer)
703                 {
704                     HeapFree(GetProcessHeap(), 0, (char *) pintern->Pointer-HGLOBAL_STORAGE);
705                     pintern->Pointer = NULL;
706                 }
707                 hnew = hmem;
708             }
709             else
710                 WARN("not freeing memory associated with locked handle\n");
711          }
712       }
713    }
714    RtlUnlockHeap(GetProcessHeap());
715    return hnew;
716 }
717
718
719 /***********************************************************************
720  *           GlobalFree   (KERNEL32.@)
721  *
722  * Free a global memory object.
723  *
724  * PARAMS
725  *  hmem [I] Handle of the global memory object
726  *
727  * RETURNS
728  *  Success: NULL
729  *  Failure: The provided handle
730  *
731  * NOTES
732  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
733  *
734  */
735 HGLOBAL WINAPI GlobalFree(HGLOBAL hmem)
736 {
737     PGLOBAL32_INTERN pintern;
738     HGLOBAL hreturned;
739
740     RtlLockHeap(GetProcessHeap());
741     __TRY
742     {
743         hreturned = 0;
744         if(ISPOINTER(hmem)) /* POINTER */
745         {
746             if(!HeapFree(GetProcessHeap(), 0, hmem))
747             {
748                 SetLastError(ERROR_INVALID_HANDLE);
749                 hreturned = hmem;
750             }
751         }
752         else  /* HANDLE */
753         {
754             pintern=HANDLE_TO_INTERN(hmem);
755
756             if(pintern->Magic==MAGIC_GLOBAL_USED)
757             {
758                 pintern->Magic = 0xdead;
759
760                 /* WIN98 does not make this test. That is you can free a */
761                 /* block you have not unlocked. Go figure!!              */
762                 /* if(pintern->LockCount!=0)  */
763                 /*    SetLastError(ERROR_INVALID_HANDLE);  */
764
765                 if(pintern->Pointer)
766                     if(!HeapFree(GetProcessHeap(), 0, (char *)(pintern->Pointer)-HGLOBAL_STORAGE))
767                         hreturned=hmem;
768                 if(!HeapFree(GetProcessHeap(), 0, pintern))
769                     hreturned=hmem;
770             }
771             else
772             {
773                 WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
774                 SetLastError(ERROR_INVALID_HANDLE);
775                 hreturned = hmem;
776             }
777         }
778     }
779     __EXCEPT_PAGE_FAULT
780     {
781         ERR("(%p): Page fault occurred ! Caused by bug ?\n", hmem);
782         SetLastError( ERROR_INVALID_PARAMETER );
783         hreturned = hmem;
784     }
785     __ENDTRY
786     RtlUnlockHeap(GetProcessHeap());
787     return hreturned;
788 }
789
790
791 /***********************************************************************
792  *           GlobalSize   (KERNEL32.@)
793  *
794  * Get the size of a global memory object.
795  *
796  * PARAMS
797  *  hmem [I] Handle of the global memory object
798  *
799  * RETURNS
800  *  Failure: 0
801  *  Success: Size in Bytes of the global memory object
802  *
803  * NOTES
804  *   When the handle is invalid, last error is set to ERROR_INVALID_HANDLE
805  *
806  */
807 SIZE_T WINAPI GlobalSize(HGLOBAL hmem)
808 {
809    DWORD                retval;
810    PGLOBAL32_INTERN     pintern;
811
812    if (!((ULONG_PTR)hmem >> 16))
813    {
814        SetLastError(ERROR_INVALID_HANDLE);
815        return 0;
816    }
817
818    if(ISPOINTER(hmem))
819    {
820       retval=HeapSize(GetProcessHeap(), 0, hmem);
821    }
822    else
823    {
824       RtlLockHeap(GetProcessHeap());
825       pintern=HANDLE_TO_INTERN(hmem);
826
827       if(pintern->Magic==MAGIC_GLOBAL_USED)
828       {
829          if (!pintern->Pointer) /* handle case of GlobalAlloc( ??,0) */
830              retval = 0;
831          else
832          {
833              retval = HeapSize(GetProcessHeap(), 0,
834                          (char *)(pintern->Pointer) - HGLOBAL_STORAGE );
835              if (retval != (DWORD)-1) retval -= HGLOBAL_STORAGE;
836          }
837       }
838       else
839       {
840          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
841          SetLastError(ERROR_INVALID_HANDLE);
842          retval=0;
843       }
844       RtlUnlockHeap(GetProcessHeap());
845    }
846    /* HeapSize returns 0xffffffff on failure */
847    if (retval == 0xffffffff) retval = 0;
848    return retval;
849 }
850
851
852 /***********************************************************************
853  *           GlobalWire   (KERNEL32.@)
854  */
855 LPVOID WINAPI GlobalWire(HGLOBAL hmem)
856 {
857    return GlobalLock( hmem );
858 }
859
860
861 /***********************************************************************
862  *           GlobalUnWire   (KERNEL32.@)
863  */
864 BOOL WINAPI GlobalUnWire(HGLOBAL hmem)
865 {
866    return GlobalUnlock( hmem);
867 }
868
869
870 /***********************************************************************
871  *           GlobalFix   (KERNEL32.@)
872  */
873 VOID WINAPI GlobalFix(HGLOBAL hmem)
874 {
875     GlobalLock( hmem );
876 }
877
878
879 /***********************************************************************
880  *           GlobalUnfix   (KERNEL32.@)
881  */
882 VOID WINAPI GlobalUnfix(HGLOBAL hmem)
883 {
884    GlobalUnlock( hmem);
885 }
886
887
888 /***********************************************************************
889  *           GlobalFlags   (KERNEL32.@)
890  *
891  * Get information about a global memory object.
892  *
893  * PARAMS
894  *  hmem [I] Handle of the global memory object 
895  *
896  * RETURNS
897  *  Failure: GMEM_INVALID_HANDLE, when the provided handle is invalid 
898  *  Success: Value specifying allocation flags and lock count
899  *
900  */
901 UINT WINAPI GlobalFlags(HGLOBAL hmem)
902 {
903    DWORD                retval;
904    PGLOBAL32_INTERN     pintern;
905
906    if(ISPOINTER(hmem))
907    {
908       retval=0;
909    }
910    else
911    {
912       RtlLockHeap(GetProcessHeap());
913       pintern=HANDLE_TO_INTERN(hmem);
914       if(pintern->Magic==MAGIC_GLOBAL_USED)
915       {
916          retval=pintern->LockCount + (pintern->Flags<<8);
917          if(pintern->Pointer==0)
918             retval|= GMEM_DISCARDED;
919       }
920       else
921       {
922          WARN("invalid handle %p (Magic: 0x%04x)\n", hmem, pintern->Magic);
923          SetLastError(ERROR_INVALID_HANDLE);
924          retval = GMEM_INVALID_HANDLE;
925       }
926       RtlUnlockHeap(GetProcessHeap());
927    }
928    return retval;
929 }
930
931
932 /***********************************************************************
933  *           GlobalCompact   (KERNEL32.@)
934  */
935 SIZE_T WINAPI GlobalCompact( DWORD minfree )
936 {
937     return 0;  /* GlobalCompact does nothing in Win32 */
938 }
939
940
941 /***********************************************************************
942  *           LocalAlloc   (KERNEL32.@)
943  *
944  * Allocate a local memory object.
945  *
946  * RETURNS
947  *      Handle: Success
948  *      NULL: Failure
949  *
950  * NOTES
951  *  Windows memory management does not provide a separate local heap
952  *  and global heap.
953  */
954 HLOCAL WINAPI LocalAlloc(
955                 UINT flags, /* [in] Allocation attributes */
956                 SIZE_T size /* [in] Number of bytes to allocate */
957 ) {
958     return GlobalAlloc( flags, size );
959 }
960
961
962 /***********************************************************************
963  *           LocalCompact   (KERNEL32.@)
964  */
965 SIZE_T WINAPI LocalCompact( UINT minfree )
966 {
967     return 0;  /* LocalCompact does nothing in Win32 */
968 }
969
970
971 /***********************************************************************
972  *           LocalFlags   (KERNEL32.@)
973  *
974  * Get information about a local memory object.
975  *
976  * RETURNS
977  *      Value specifying allocation flags and lock count.
978  *      LMEM_INVALID_HANDLE: Failure
979  *
980  * NOTES
981  *  Windows memory management does not provide a separate local heap
982  *  and global heap.
983  */
984 UINT WINAPI LocalFlags(
985               HLOCAL handle /* [in] Handle of memory object */
986 ) {
987     return GlobalFlags( handle );
988 }
989
990
991 /***********************************************************************
992  *           LocalFree   (KERNEL32.@)
993  *
994  * Free a local memory object.
995  *
996  * RETURNS
997  *      NULL: Success
998  *      Handle: Failure
999  *
1000  * NOTES
1001  *  Windows memory management does not provide a separate local heap
1002  *  and global heap.
1003  */
1004 HLOCAL WINAPI LocalFree(
1005                 HLOCAL handle /* [in] Handle of memory object */
1006 ) {
1007     return GlobalFree( handle );
1008 }
1009
1010
1011 /***********************************************************************
1012  *           LocalHandle   (KERNEL32.@)
1013  *
1014  * Get the handle associated with the pointer to a local memory block.
1015  *
1016  * RETURNS
1017  *      Handle: Success
1018  *      NULL: Failure
1019  *
1020  * NOTES
1021  *  Windows memory management does not provide a separate local heap
1022  *  and global heap.
1023  */
1024 HLOCAL WINAPI LocalHandle(
1025                 LPCVOID ptr /* [in] Address of local memory block */
1026 ) {
1027     return GlobalHandle( ptr );
1028 }
1029
1030
1031 /***********************************************************************
1032  *           LocalLock   (KERNEL32.@)
1033  * Locks a local memory object and returns pointer to the first byte
1034  * of the memory block.
1035  *
1036  * RETURNS
1037  *      Pointer: Success
1038  *      NULL: Failure
1039  *
1040  * NOTES
1041  *  Windows memory management does not provide a separate local heap
1042  *  and global heap.
1043  */
1044 LPVOID WINAPI LocalLock(
1045               HLOCAL handle /* [in] Address of local memory object */
1046 ) {
1047     return GlobalLock( handle );
1048 }
1049
1050
1051 /***********************************************************************
1052  *           LocalReAlloc   (KERNEL32.@)
1053  *
1054  * Change the size or attributes of a local memory object.
1055  *
1056  * RETURNS
1057  *      Handle: Success
1058  *      NULL: Failure
1059  *
1060  * NOTES
1061  *  Windows memory management does not provide a separate local heap
1062  *  and global heap.
1063  */
1064 HLOCAL WINAPI LocalReAlloc(
1065                 HLOCAL handle, /* [in] Handle of memory object */
1066                 SIZE_T size,   /* [in] New size of block */
1067                 UINT flags     /* [in] How to reallocate object */
1068 ) {
1069     return GlobalReAlloc( handle, size, flags );
1070 }
1071
1072
1073 /***********************************************************************
1074  *           LocalShrink   (KERNEL32.@)
1075  */
1076 SIZE_T WINAPI LocalShrink( HGLOBAL handle, UINT newsize )
1077 {
1078     return 0;  /* LocalShrink does nothing in Win32 */
1079 }
1080
1081
1082 /***********************************************************************
1083  *           LocalSize   (KERNEL32.@)
1084  *
1085  * Get the size of a local memory object.
1086  *
1087  * RETURNS
1088  *      Size: Success
1089  *      0: Failure
1090  *
1091  * NOTES
1092  *  Windows memory management does not provide a separate local heap
1093  *  and global heap.
1094  */
1095 SIZE_T WINAPI LocalSize(
1096               HLOCAL handle /* [in] Handle of memory object */
1097 ) {
1098     return GlobalSize( handle );
1099 }
1100
1101
1102 /***********************************************************************
1103  *           LocalUnlock   (KERNEL32.@)
1104  *
1105  * Unlock a local memory object.
1106  *
1107  * RETURNS
1108  *      TRUE: Object is still locked
1109  *      FALSE: Object is unlocked
1110  *
1111  * NOTES
1112  *  Windows memory management does not provide a separate local heap
1113  *  and global heap.
1114  */
1115 BOOL WINAPI LocalUnlock(
1116               HLOCAL handle /* [in] Handle of memory object */
1117 ) {
1118     return GlobalUnlock( handle );
1119 }
1120
1121
1122 /**********************************************************************
1123  *              AllocMappedBuffer       (KERNEL32.38)
1124  *
1125  * This is an undocumented KERNEL32 function that
1126  * SMapLS's a GlobalAlloc'ed buffer.
1127  *
1128  * RETURNS
1129  *       EDI register: pointer to buffer
1130  *
1131  * NOTES
1132  *       The buffer is preceded by 8 bytes:
1133  *        ...
1134  *       edi+0   buffer
1135  *       edi-4   SEGPTR to buffer
1136  *       edi-8   some magic Win95 needs for SUnMapLS
1137  *               (we use it for the memory handle)
1138  *
1139  *       The SEGPTR is used by the caller!
1140  */
1141 void WINAPI __regs_AllocMappedBuffer(
1142               CONTEXT86 *context /* [in] EDI register: size of buffer to allocate */
1143 ) {
1144     HGLOBAL handle = GlobalAlloc(0, context->Edi + 8);
1145     DWORD *buffer = (DWORD *)GlobalLock(handle);
1146     DWORD ptr = 0;
1147
1148     if (buffer)
1149         if (!(ptr = MapLS(buffer + 2)))
1150         {
1151             GlobalUnlock(handle);
1152             GlobalFree(handle);
1153         }
1154
1155     if (!ptr)
1156         context->Eax = context->Edi = 0;
1157     else
1158     {
1159         buffer[0] = (DWORD)handle;
1160         buffer[1] = ptr;
1161
1162         context->Eax = ptr;
1163         context->Edi = (DWORD)(buffer + 2);
1164     }
1165 }
1166 #ifdef DEFINE_REGS_ENTRYPOINT
1167 DEFINE_REGS_ENTRYPOINT( AllocMappedBuffer, 0, 0 )
1168 #endif
1169
1170 /**********************************************************************
1171  *              FreeMappedBuffer        (KERNEL32.39)
1172  *
1173  * Free a buffer allocated by AllocMappedBuffer
1174  *
1175  * RETURNS
1176  *  Nothing.
1177  */
1178 void WINAPI __regs_FreeMappedBuffer(
1179               CONTEXT86 *context /* [in] EDI register: pointer to buffer */
1180 ) {
1181     if (context->Edi)
1182     {
1183         DWORD *buffer = (DWORD *)context->Edi - 2;
1184
1185         UnMapLS(buffer[1]);
1186
1187         GlobalUnlock((HGLOBAL)buffer[0]);
1188         GlobalFree((HGLOBAL)buffer[0]);
1189     }
1190 }
1191 #ifdef DEFINE_REGS_ENTRYPOINT
1192 DEFINE_REGS_ENTRYPOINT( FreeMappedBuffer, 0, 0 )
1193 #endif
1194
1195 /***********************************************************************
1196  *           GlobalMemoryStatusEx   (KERNEL32.@)
1197  * A version of GlobalMemoryStatus that can deal with memory over 4GB
1198  *
1199  * RETURNS
1200  *      TRUE
1201  */
1202 BOOL WINAPI GlobalMemoryStatusEx( LPMEMORYSTATUSEX lpmemex )
1203 {
1204     static MEMORYSTATUSEX       cached_memstatus;
1205     static int cache_lastchecked = 0;
1206     SYSTEM_INFO si;
1207 #ifdef linux
1208     FILE *f;
1209 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__)
1210     unsigned long val;
1211     int mib[2];
1212     size_t size_sys;
1213 #elif defined(__APPLE__)
1214     unsigned int val;
1215     int mib[2];
1216     size_t size_sys;
1217 #elif defined(sun)
1218     unsigned long pagesize,maxpages,freepages,swapspace,swapfree;
1219     struct anoninfo swapinf;
1220     int rval;
1221 #endif
1222
1223     if (lpmemex->dwLength != sizeof(*lpmemex))
1224     {
1225         SetLastError( ERROR_INVALID_PARAMETER );
1226         return FALSE;
1227     }
1228
1229     if (time(NULL)==cache_lastchecked) {
1230         *lpmemex = cached_memstatus;
1231         return TRUE;
1232     }
1233     cache_lastchecked = time(NULL);
1234
1235     lpmemex->dwMemoryLoad     = 0;
1236     lpmemex->ullTotalPhys     = 16*1024*1024;
1237     lpmemex->ullAvailPhys     = 16*1024*1024;
1238     lpmemex->ullTotalPageFile = 16*1024*1024;
1239     lpmemex->ullAvailPageFile = 16*1024*1024;
1240
1241 #ifdef linux
1242     f = fopen( "/proc/meminfo", "r" );
1243     if (f)
1244     {
1245         char buffer[256];
1246         unsigned long total, used, free, shared, buffers, cached;
1247
1248         lpmemex->ullTotalPhys = lpmemex->ullAvailPhys = 0;
1249         lpmemex->ullTotalPageFile = lpmemex->ullAvailPageFile = 0;
1250         while (fgets( buffer, sizeof(buffer), f ))
1251         {
1252             /* old style /proc/meminfo ... */
1253             if (sscanf( buffer, "Mem: %lu %lu %lu %lu %lu %lu",
1254                         &total, &used, &free, &shared, &buffers, &cached ))
1255             {
1256                 lpmemex->ullTotalPhys += total;
1257                 lpmemex->ullAvailPhys += free + buffers + cached;
1258             }
1259             if (sscanf( buffer, "Swap: %lu %lu %lu", &total, &used, &free ))
1260             {
1261                 lpmemex->ullTotalPageFile += total;
1262                 lpmemex->ullAvailPageFile += free;
1263             }
1264
1265             /* new style /proc/meminfo ... */
1266             if (sscanf(buffer, "MemTotal: %lu", &total))
1267                 lpmemex->ullTotalPhys = total*1024;
1268             if (sscanf(buffer, "MemFree: %lu", &free))
1269                 lpmemex->ullAvailPhys = free*1024;
1270             if (sscanf(buffer, "SwapTotal: %lu", &total))
1271                 lpmemex->ullTotalPageFile = total*1024;
1272             if (sscanf(buffer, "SwapFree: %lu", &free))
1273                 lpmemex->ullAvailPageFile = free*1024;
1274             if (sscanf(buffer, "Buffers: %lu", &buffers))
1275                 lpmemex->ullAvailPhys += buffers*1024;
1276             if (sscanf(buffer, "Cached: %lu", &cached))
1277                 lpmemex->ullAvailPhys += cached*1024;
1278         }
1279         fclose( f );
1280     }
1281 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__NetBSD__) || defined(__APPLE__)
1282     mib[0] = CTL_HW;
1283     mib[1] = HW_PHYSMEM;
1284     size_sys = sizeof(val);
1285     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1286     if (val) lpmemex->ullTotalPhys = val;
1287     mib[1] = HW_USERMEM;
1288     size_sys = sizeof(val);
1289     sysctl(mib, 2, &val, &size_sys, NULL, 0);
1290     if (!val) val = lpmemex->ullTotalPhys;
1291     lpmemex->ullAvailPhys = val;
1292     lpmemex->ullTotalPageFile = val;
1293     lpmemex->ullAvailPageFile = val;
1294 #elif defined ( sun )
1295     pagesize=sysconf(_SC_PAGESIZE);
1296     maxpages=sysconf(_SC_PHYS_PAGES);
1297     freepages=sysconf(_SC_AVPHYS_PAGES);
1298     rval=swapctl(SC_AINFO, &swapinf);
1299     if(rval >-1)
1300     {
1301         swapspace=swapinf.ani_max*pagesize;
1302         swapfree=swapinf.ani_free*pagesize;
1303     }else
1304     {
1305
1306         WARN("Swap size cannot be determined , assuming equal to physical memory\n");
1307         swapspace=maxpages*pagesize;
1308         swapfree=maxpages*pagesize;
1309     }
1310     lpmemex->ullTotalPhys=pagesize*maxpages;
1311     lpmemex->ullAvailPhys = pagesize*freepages;
1312     lpmemex->ullTotalPageFile = swapspace;
1313     lpmemex->ullAvailPageFile = swapfree;
1314 #endif
1315
1316     if (lpmemex->ullTotalPhys)
1317     {
1318         lpmemex->dwMemoryLoad = (lpmemex->ullTotalPhys-lpmemex->ullAvailPhys)
1319                                   / (lpmemex->ullTotalPhys / 100);
1320     }
1321
1322     /* Win98 returns only the swapsize in ullTotalPageFile/ullAvailPageFile,
1323        WinXP returns the size of physical memory + swapsize;
1324        mimic the behavior of XP.
1325        Note: Project2k refuses to start if it sees less than 1Mb of free swap.
1326     */
1327     lpmemex->ullTotalPageFile += lpmemex->ullTotalPhys;
1328     lpmemex->ullAvailPageFile += lpmemex->ullAvailPhys;
1329
1330     /* Titan Quest refuses to run if TotalPageFile <= ullTotalPhys */
1331     if(lpmemex->ullTotalPageFile == lpmemex->ullTotalPhys)
1332     {
1333         lpmemex->ullTotalPhys -= 1;
1334         lpmemex->ullAvailPhys -= 1;
1335     }
1336
1337     /* FIXME: should do something for other systems */
1338     GetSystemInfo(&si);
1339     lpmemex->ullTotalVirtual  = (char*)si.lpMaximumApplicationAddress-(char*)si.lpMinimumApplicationAddress;
1340     /* FIXME: we should track down all the already allocated VM pages and substract them, for now arbitrarily remove 64KB so that it matches NT */
1341     lpmemex->ullAvailVirtual  = lpmemex->ullTotalVirtual-64*1024;
1342
1343     /* MSDN says about AvailExtendedVirtual: Size of unreserved and uncommitted
1344        memory in the extended portion of the virtual address space of the calling
1345        process, in bytes.
1346        However, I don't know what this means, so set it to zero :(
1347     */
1348     lpmemex->ullAvailExtendedVirtual = 0;
1349
1350     cached_memstatus = *lpmemex;
1351
1352     TRACE("<-- LPMEMORYSTATUSEX: dwLength %d, dwMemoryLoad %d, ullTotalPhys %s, ullAvailPhys %s,"
1353           " ullTotalPageFile %s, ullAvailPageFile %s, ullTotalVirtual %s, ullAvailVirtual %s\n",
1354           lpmemex->dwLength, lpmemex->dwMemoryLoad, wine_dbgstr_longlong(lpmemex->ullTotalPhys),
1355           wine_dbgstr_longlong(lpmemex->ullAvailPhys), wine_dbgstr_longlong(lpmemex->ullTotalPageFile),
1356           wine_dbgstr_longlong(lpmemex->ullAvailPageFile), wine_dbgstr_longlong(lpmemex->ullTotalVirtual),
1357           wine_dbgstr_longlong(lpmemex->ullAvailVirtual) );
1358
1359     return TRUE;
1360 }
1361
1362 /***********************************************************************
1363  *           GlobalMemoryStatus   (KERNEL32.@)
1364  * Provides information about the status of the memory, so apps can tell
1365  * roughly how much they are able to allocate
1366  *
1367  * RETURNS
1368  *      None
1369  */
1370 VOID WINAPI GlobalMemoryStatus( LPMEMORYSTATUS lpBuffer )
1371 {
1372     MEMORYSTATUSEX memstatus;
1373     OSVERSIONINFOW osver;
1374     IMAGE_NT_HEADERS *nt = RtlImageNtHeader( GetModuleHandleW(0) );
1375
1376     /* Because GlobalMemoryStatus is identical to GlobalMemoryStatusEX save
1377        for one extra field in the struct, and the lack of a bug, we simply
1378        call GlobalMemoryStatusEx and copy the values across. */
1379     memstatus.dwLength = sizeof(memstatus);
1380     GlobalMemoryStatusEx(&memstatus);
1381
1382     lpBuffer->dwLength = sizeof(*lpBuffer);
1383     lpBuffer->dwMemoryLoad = memstatus.dwMemoryLoad;
1384
1385     /* Windows 2000 and later report -1 when values are greater than 4 Gb.
1386      * NT reports values modulo 4 Gb.
1387      */
1388
1389     osver.dwOSVersionInfoSize = sizeof(osver);
1390     GetVersionExW(&osver);
1391
1392     if ( osver.dwMajorVersion >= 5 )
1393     {
1394         lpBuffer->dwTotalPhys = min( memstatus.ullTotalPhys, MAXDWORD );
1395         lpBuffer->dwAvailPhys = min( memstatus.ullAvailPhys, MAXDWORD );
1396         lpBuffer->dwTotalPageFile = min( memstatus.ullTotalPageFile, MAXDWORD );
1397         lpBuffer->dwAvailPageFile = min( memstatus.ullAvailPageFile, MAXDWORD );
1398         lpBuffer->dwTotalVirtual = min( memstatus.ullTotalVirtual, MAXDWORD );
1399         lpBuffer->dwAvailVirtual = min( memstatus.ullAvailVirtual, MAXDWORD );
1400
1401     }
1402     else        /* duplicate NT bug */
1403     {
1404         lpBuffer->dwTotalPhys = memstatus.ullTotalPhys;
1405         lpBuffer->dwAvailPhys = memstatus.ullAvailPhys;
1406         lpBuffer->dwTotalPageFile = memstatus.ullTotalPageFile;
1407         lpBuffer->dwAvailPageFile = memstatus.ullAvailPageFile;
1408         lpBuffer->dwTotalVirtual = memstatus.ullTotalVirtual;
1409         lpBuffer->dwAvailVirtual = memstatus.ullAvailVirtual;
1410     }
1411
1412     /* values are limited to 2Gb unless the app has the IMAGE_FILE_LARGE_ADDRESS_AWARE flag */
1413     /* page file sizes are not limited (Adobe Illustrator 8 depends on this) */
1414     if (!(nt->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE))
1415     {
1416         if (lpBuffer->dwTotalPhys > MAXLONG) lpBuffer->dwTotalPhys = MAXLONG;
1417         if (lpBuffer->dwAvailPhys > MAXLONG) lpBuffer->dwAvailPhys = MAXLONG;
1418         if (lpBuffer->dwTotalVirtual > MAXLONG) lpBuffer->dwTotalVirtual = MAXLONG;
1419         if (lpBuffer->dwAvailVirtual > MAXLONG) lpBuffer->dwAvailVirtual = MAXLONG;
1420     }
1421
1422     /* work around for broken photoshop 4 installer */
1423     if ( lpBuffer->dwAvailPhys +  lpBuffer->dwAvailPageFile >= 2U*1024*1024*1024)
1424          lpBuffer->dwAvailPageFile = 2U*1024*1024*1024 -  lpBuffer->dwAvailPhys - 1;
1425
1426     /* limit page file size for really old binaries */
1427     if (nt->OptionalHeader.MajorSubsystemVersion < 4)
1428     {
1429         if (lpBuffer->dwTotalPageFile > MAXLONG) lpBuffer->dwTotalPageFile = MAXLONG;
1430         if (lpBuffer->dwAvailPageFile > MAXLONG) lpBuffer->dwAvailPageFile = MAXLONG;
1431     }
1432
1433     TRACE("Length %u, MemoryLoad %u, TotalPhys %lx, AvailPhys %lx,"
1434           " TotalPageFile %lx, AvailPageFile %lx, TotalVirtual %lx, AvailVirtual %lx\n",
1435           lpBuffer->dwLength, lpBuffer->dwMemoryLoad, lpBuffer->dwTotalPhys,
1436           lpBuffer->dwAvailPhys, lpBuffer->dwTotalPageFile, lpBuffer->dwAvailPageFile,
1437           lpBuffer->dwTotalVirtual, lpBuffer->dwAvailVirtual );
1438 }