Disable LFH on Windows?

Based on Michael Burr's comment above about an IMAGE_LOAD_CONFIG_DIRECTORY containing a GlobalFlagSet, I wrote the following code to demonstrate that a proper GlobalFlag disables a bunch of low fragmentation. One of the caveats about writing your own IMAGE_LOAD_CONFIG_DIRECTORY at compile time is that it disables SafeSEH.

// editloadconfig.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include <windows.h>

#include <tchar.h>
#include <stdio.h>


/*
typedef struct {
    DWORD   Size;
    DWORD   TimeDateStamp;
    WORD    MajorVersion;
    WORD    MinorVersion;
    DWORD   GlobalFlagsClear;
    DWORD   GlobalFlagsSet;
    DWORD   CriticalSectionDefaultTimeout;
    DWORD   DeCommitFreeBlockThreshold;
    DWORD   DeCommitTotalFreeThreshold;
    DWORD   LockPrefixTable;            // VA
    DWORD   MaximumAllocationSize;
    DWORD   VirtualMemoryThreshold;
    DWORD   ProcessHeapFlags;
    DWORD   ProcessAffinityMask;
    WORD    CSDVersion;
    WORD    Reserved1;
    DWORD   EditList;                   // VA
    DWORD   SecurityCookie;             // VA
    DWORD   SEHandlerTable;             // VA
    DWORD   SEHandlerCount;
} IMAGE_LOAD_CONFIG_DIRECTORY32, *PIMAGE_LOAD_CONFIG_DIRECTORY32;
*/


extern "C" 
IMAGE_LOAD_CONFIG_DIRECTORY _load_config_used = { 0x48, 0, 0, 0,0, 0x00000020/*enable heap free checking*/};
// change the last value to 0 to not enable any globalflags


#define HEAP_STANDARD 0
#define HEAP_LAL 1
#define HEAP_LFH 2
#define SIZE 100

int _tmain(int argc, _TCHAR* argv[])
{
   BOOL bResult;
   HANDLE hHeap;
   ULONG HeapInformation;
   void* allocb[0x12+1];


   // based on "Understanding the LFH" paper at
   // http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=5&ved=0CE0QFjAE&url=http%3A%2F%2Fillmatics.com%2FUnderstanding_the_LFH.pdf&ei=GlBvT9yrMKHy0gGHpLnaBg&usg=AFQjCNGsvVtl54X7MWGyWYqiSrsdTBrbXQ
   int i = 0;
   for(i = 0; i < 0x12; i++) 
   { 
        printf("Allocation 0x%02x for 0x%02x bytes\n", i, SIZE); 
        allocb[i] = HeapAlloc(GetProcessHeap(), 0x0, SIZE); 
   }

   printf("Allocation 0x%02x for 0x%02x bytes\n", i++, SIZE); 
   printf("\tFirst serviced by the LFH\n"); 
   allocb[i] = HeapAlloc(GetProcessHeap(), 0x0, SIZE);
   // LFH is now activated so the query below will return 0 or 2.

   // sample code from MSDN for querying heap information
   //
   // Get a handle to the default process heap.
   //
   hHeap = GetProcessHeap();
   if (hHeap == NULL) {
       _tprintf(TEXT("Failed to retrieve default process heap with LastError %d.\n"),
                GetLastError());
       return 1;
   }

   //
   // Query heap features that are enabled.
   //
   bResult = HeapQueryInformation(hHeap,
                                  HeapCompatibilityInformation,
                                  &HeapInformation,
                                  sizeof(HeapInformation),
                                  NULL);
   if (bResult == FALSE) {
       _tprintf(TEXT("Failed to retrieve heap features with LastError %d.\n"),
                GetLastError());
       return 1;
   }

   //
   // Print results of the query.
   //
   _tprintf(TEXT("HeapCompatibilityInformation is %d.\n"), HeapInformation);
   switch(HeapInformation)
   {
   case HEAP_STANDARD:
       _tprintf(TEXT("The default process heap is a standard heap.\n"));
       break;
   case HEAP_LAL:
       _tprintf(TEXT("The default process heap supports look-aside lists.\n"));
       break;
   case HEAP_LFH:
       _tprintf(TEXT("The default process heap has the low-fragmentation ") \
                TEXT("heap enabled.\n"));
       break;
   default:
       _tprintf(TEXT("Unrecognized HeapInformation reported for the default ") \
                TEXT("process heap.\n"));
       break;
    }

   return 0; 
}