windows-server-2003/sdktools/gflags/gflags.cxx

/*++

Copyright (c) 2001 Microsoft Corporation

Module Name:

    gflags.cxx

Abstract:

    This module contains the routines to make global flags 
    settings (i.e. the FLG_XXX constants from ntexapi.h).

Author:

    - others -                                     
    Silviu Calinoiu (silviuc) 09-Nov-2001

Revision History:

--*/

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <ntexapi.dbg>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include "gflags.h"

//
// Valid global flag bits for the three scenarios: per image flags,
// system wide flags (require a reboot or will affect future processes
// in user mode) and kernel mode flags on the fly.
//

#define GFLGS_VALID_KERNEL_MODE_FLAGS ((VALID_KERNEL_MODE_FLAGS) \
                                       & ~FLG_KERNEL_STACK_TRACE_DB \
                                       & ~FLG_POOL_ENABLE_TAGGING)

#define GFLGS_VALID_SYSTEM_REGISTRY_FLAGS ((VALID_SYSTEM_REGISTRY_FLAGS))

#define GFLGS_VALID_IMAGE_FILE_NAME_FLAGS ((VALID_IMAGE_FILE_NAME_FLAGS))


CHAR GflagsHelpText[] = 
    "                                                                  \n"
    "usage: GFLAGS [-r [<Flags>]] |                                    \n"
    "              [-k [<Flags>]] |                                    \n"
    "              [-i <ImageFileName> [<Flags>]] |                    \n"
    "              [-i <ImageFileName> -tracedb <SizeInMb>] |          \n"
    "              [-p <PageHeapOptions>] (use `-p ?' for help)        \n"
    "                                                                  \n"
    "where: <Flags> is a 32 bit hex number (0x12345678) that specifies \n"
    "       one or more global flags to set.                           \n"
    "       -r operates on system registry settings.                   \n"
    "       -k operates on kernel settings of the running system.      \n"
    "       -i operates on settings for a specific image file.         \n"
    "                                                                  \n"
    "       If only the switch is specified, then current settings     \n"
    "       are displayed, not modified.  If flags specified for -i    \n"
    "       option are FFFFFFFF, then registry entry for that image    \n"
    "       is deleted                                                 \n"
    "                                                                  \n"
    "The `-tracedb' option is used to set the size of the stack trace  \n"
    "database used to store runtime stack traces. The actual database  \n"
    "will be created if the `+ust' flag is set in a previous command.  \n"
    "`-tracedb 0' will revert to the default size for the database.    \n"
    "                                                                  \n"
    "If no arguments are specified to GFLAGS then it displays          \n"
    "a dialog box that allows the user to modify the global            \n"
    "flag settings.                                                    \n"
    "                                                                  \n"
    "Flags may either be a single hex number that specifies all        \n"
    "32-bits of the GlobalFlags value, or it can be one or more        \n"
    "arguments, each beginning with a + or -, where the + means        \n"
    "to set the corresponding bit(s) in the GlobalFlags and a -        \n"
    "means to clear the corresponding bit(s).  After the + or -        \n"
    "may be either a hex number or a three letter abbreviation         \n"
    "for a GlobalFlag.  Valid abbreviations are:                       \n"
    "                                                                  \n";

#define _PART_OF_GFLAGS_ 1
#include "..\pageheap\pageheap.cxx"

#if defined(_X86_)

//
// Use function pointers for ntdll import functions so gflags
// can fail with a user friendly message on win9x.
//

#define RtlIntegerToChar            pRtlIntegerToChar
#define NtQueryInformationProcess   pNtQueryInformationProcess
#define RtlCharToInteger            pRtlCharToInteger
#define NtSetSystemInformation      pNtSetSystemInformation
#define NtQuerySystemInformation    pNtQuerySystemInformation

typedef NTSTATUS (NTAPI *PRTLINTEGERTOCHAR)(
    ULONG,
    ULONG,
    LONG,
    PSZ
    );

typedef NTSTATUS (NTAPI *PNTQUERYINFORMATIONPROCESS) (
    IN HANDLE,
    IN PROCESSINFOCLASS,
    OUT PVOID,
    IN ULONG,
    OUT PULONG
    );

typedef NTSTATUS (NTAPI * PRTLCHARTOINTEGER) (
    PCSZ,
    ULONG,
    PULONG
    );

typedef NTSTATUS (NTAPI * PNTSETSYSTEMINFORMATION) (
    IN SYSTEM_INFORMATION_CLASS,
    IN PVOID,
    IN ULONG
    );


typedef NTSTATUS (NTAPI * PNTQUERYSYSTEMINFORMATION) (
    IN SYSTEM_INFORMATION_CLASS,
    OUT PVOID,
    IN ULONG,
    OUT PULONG
    );

PRTLINTEGERTOCHAR pRtlIntegerToChar;
PNTQUERYINFORMATIONPROCESS pNtQueryInformationProcess;
PRTLCHARTOINTEGER pRtlCharToInteger;
PNTSETSYSTEMINFORMATION pNtSetSystemInformation;
PNTQUERYSYSTEMINFORMATION pNtQuerySystemInformation;

#endif


BOOL
GflagsSetTraceDatabaseSize (
    PCHAR ApplicationName,
    ULONG SizeInMb,
    PULONG RealSize
    );

INT_PTR  APIENTRY MainWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);

BOOL
EnableDebugPrivilege( VOID );

BOOL
OkToEnablePagedHeap( VOID );

HWND hwndMain;
HWND hwndPagedHeapDlg;

HKEY hSmKey, hMmKey;
DWORD InitialSetFlags;
DWORD LastSetFlags;

//
// Special pool management
//

#define SPECIAL_POOL_OVERRUNS_CHECK_FORWARD   1
#define SPECIAL_POOL_OVERRUNS_CHECK_BACKWARD  0

DWORD LastSetSpecialPoolTag;
DWORD LastSetSpecialPoolOverruns = SPECIAL_POOL_OVERRUNS_CHECK_FORWARD;

TCHAR SpecialPoolRenderBuffer[8 + 1];



CHAR LastDebuggerValue[ MAX_PATH ];

UINT SpecialPool[] = {
        ID_SPECIAL_POOL_GROUP,
        ID_SPECIAL_POOL_IS_TEXT,
        ID_SPECIAL_POOL_IS_NUMBER,
        ID_SPECIAL_POOL_TAG,
        ID_SPECIAL_POOL_VERIFY_START,
        ID_SPECIAL_POOL_VERIFY_END,
        0
        };

UINT Debugger[] = {
        ID_IMAGE_DEBUGGER_GROUP,
        ID_IMAGE_DEBUGGER_VALUE,
        ID_IMAGE_DEBUGGER_BUTTON,
        0
        };

PCHAR SystemProcesses[] = {
        "csrss.exe",
        "winlogon.exe",
        "services.exe",
        "lsass.exe",
        "svchost.exe",
        "ntmssvc.exe",
        "rpcss.exe",
        "spoolsv.exe"
        };

//
// POOL Tagging is always on for .NET server, the "Enable pool tagging" option
// will be greyed out if it is on a .NET server.
// Pool Tagging on XP will still be controlled by GFlags same as w2k.
//
BOOL 	PoolTaggingAlwaysOn = FALSE;
ULONG	PoolTagEnabledFlag  = 0;

EnableSetOfControls(
    HWND hDlg,
    UINT * Controls,
    BOOL Enable
    )
{
    UINT Control ;
    HWND hWnd ;

    Control = *Controls++ ;
    while ( Control )
    {
        hWnd = GetDlgItem( hDlg, Control );

        EnableWindow( hWnd, Enable );

        ShowWindow( hWnd, Enable ? SW_NORMAL : SW_HIDE );

        Control = *Controls++ ;
    }

    return 0;
}

DWORD
GetSystemRegistryFlags( VOID )
{
    DWORD cbKey;
    DWORD GFlags;
    DWORD type;

    if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                      "SYSTEM\\CurrentControlSet\\Control\\Session Manager",
                      0,
                      KEY_READ | KEY_WRITE,
                      &hSmKey
                    ) != ERROR_SUCCESS
       ) {
        MessageBox( hwndMain, "Open Error", "SYSTEM\\CurrentControlSet\\Control\\Session Manager", MB_OK );
        ExitProcess( 0 );
        }

    cbKey = sizeof( GFlags );
    if (RegQueryValueEx( hSmKey,
                         "GlobalFlag",
                         0,
                         &type,
                         (LPBYTE)&GFlags,
                         &cbKey
                       ) != ERROR_SUCCESS ||
        type != REG_DWORD
       ) {
        MessageBox( hwndMain, "Value Error", "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\GlobalFlag", MB_OK );
        RegCloseKey( hSmKey );
        ExitProcess( 0 );
        }

    if (RegOpenKeyEx( HKEY_LOCAL_MACHINE,
                      "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management",
                      0,
                      KEY_READ | KEY_WRITE,
                      &hMmKey
                    ) != ERROR_SUCCESS
       ) {
        MessageBox( hwndMain, "Open Error", "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management", MB_OK );
        RegCloseKey( hSmKey );
        ExitProcess( 0 );
        }

    cbKey = sizeof( LastSetSpecialPoolTag );
    if (RegQueryValueEx( hMmKey,
                         "PoolTag",
                         0,
                         &type,
                         (LPBYTE)&LastSetSpecialPoolTag,
                         &cbKey
                       ) == ERROR_SUCCESS
        ) {

        if (type != REG_DWORD) {
            MessageBox( hwndMain, "Value Error", "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management\\PoolTag", MB_OK );
            RegCloseKey( hSmKey );
            RegCloseKey( hMmKey );
            ExitProcess( 0 );
        }
    } else {
        LastSetSpecialPoolTag = 0;
    }

    cbKey = sizeof( LastSetSpecialPoolOverruns );
    if (RegQueryValueEx( hMmKey,
                         "PoolTagOverruns",
                         0,
                         &type,
                         (LPBYTE)&LastSetSpecialPoolOverruns,
                         &cbKey
                       ) == ERROR_SUCCESS
        ) {

        if (type != REG_DWORD) {

            MessageBox( hwndMain,
                        "Value Type Error",
                        "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management"
                        "\\PoolTagOverruns",
                        MB_OK );
            RegCloseKey( hSmKey );
            RegCloseKey( hMmKey );
            ExitProcess( 0 );
        }

        //
        // The only legal values are 0, 1.
        //

        if (LastSetSpecialPoolOverruns != SPECIAL_POOL_OVERRUNS_CHECK_BACKWARD &&
            LastSetSpecialPoolOverruns != SPECIAL_POOL_OVERRUNS_CHECK_FORWARD) {

            MessageBox( hwndMain,
                        "Value Data Error",
                        "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management"
                        "\\PoolTagOverruns",
                        MB_OK );
            RegCloseKey( hSmKey );
            RegCloseKey( hMmKey );
            ExitProcess( 0 );
        }

    } else {
        LastSetSpecialPoolOverruns = SPECIAL_POOL_OVERRUNS_CHECK_FORWARD;
    }

    return GFlags;
}

BOOLEAN
SetSystemRegistryFlags(
    DWORD GFlags,
    DWORD SpecialPoolTag,
    DWORD SpecialPoolOverruns
    )
{
    if (RegSetValueEx( hSmKey,
                       "GlobalFlag",
                       0,
                       REG_DWORD,
                       (LPBYTE)&GFlags,
                       sizeof( GFlags )
                     ) != ERROR_SUCCESS
       ) {
        MessageBox( hwndMain, "Value Error", "SYSTEM\\CurrentControlSet\\Control\\Session Manager\\GlobalFlag", MB_OK );
        RegCloseKey( hSmKey );
        RegCloseKey( hMmKey );
        ExitProcess( 0 );
        }

    //
    //  Only modify special pool if we went to GUI mode
    //

    if (hwndMain) {

        if (SpecialPoolTag) {

            if (RegSetValueEx( hMmKey,
                               "PoolTag",
                               0,
                               REG_DWORD,
                               (LPBYTE)&SpecialPoolTag,
                               sizeof( SpecialPoolTag )
                               ) != ERROR_SUCCESS
                ) {
                MessageBox( hwndMain,
                            "Value Error",
                            "SYSTEM\\CurrentControlSet\\Control\\Session Manager"
                            "\\Memory Management\\PoolTag",
                            MB_OK );
                RegCloseKey( hSmKey );
                RegCloseKey( hMmKey );
                ExitProcess( 0 );
            }

            if (RegSetValueEx( hMmKey,
                               "PoolTagOverruns",
                               0,
                               REG_DWORD,
                               (LPBYTE)&SpecialPoolOverruns,
                               sizeof( SpecialPoolOverruns )
                               ) != ERROR_SUCCESS
                ) {
                MessageBox( hwndMain,
                            "Value Error",
                            "SYSTEM\\CurrentControlSet\\Control\\Session Manager"
                            "\\Memory Management\\PoolTag",
                            MB_OK );
                RegCloseKey( hSmKey );
                RegCloseKey( hMmKey );
                ExitProcess( 0 );
            }


        } else {

            RegDeleteValue( hMmKey,
                            "PoolTag"
                          );

            RegDeleteValue( hMmKey,
                            "PoolTagOverruns"
                          );
        }
    }

    LastSetFlags = GFlags;

    LastSetSpecialPoolTag = SpecialPoolTag;
    LastSetSpecialPoolOverruns = SpecialPoolOverruns;

    return TRUE;
}

DWORD
GetKernelModeFlags( VOID )
{
    NTSTATUS Status;
    SYSTEM_FLAGS_INFORMATION SystemInformation;

    Status = NtQuerySystemInformation( SystemFlagsInformation,
                                       &SystemInformation,
                                       sizeof( SystemInformation ),
                                       NULL
                                     );
    if (!NT_SUCCESS( Status )) {
        MessageBox( hwndMain, "Value Error", "Kernel Mode Flags", MB_OK );
        ExitProcess( 0 );
        }

    return SystemInformation.Flags;
}

BOOLEAN
AddImageNameToUSTString(
    PCHAR ImageFileName
    )
{
    CHAR *Enabled = NULL;
    HKEY hKey;
    DWORD Result;
    DWORD Length;

    if (strlen( ImageFileName ) == 0)
        return FALSE;

    // Open the Key
    Result = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
                            "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options",
                            0,
                            NULL,
                            REG_OPTION_NON_VOLATILE,
                            KEY_ALL_ACCESS,
                            NULL,
                            &hKey,
                            NULL
                            );

    if (Result == ERROR_SUCCESS) {
        // Get the current length of the registry key
        Result = RegQueryValueEx( hKey, "USTEnabled", NULL, NULL, NULL, &Length );

        if (Result == ERROR_SUCCESS){
            // Get a buffer big enough for current key, a ';', and our new name.
            Enabled = (PCHAR)malloc(Length + strlen(ImageFileName)+ 1);

            if (Enabled) {
                // Get the current key value
                Result = RegQueryValueEx( hKey, "USTEnabled", NULL, NULL, (PBYTE)Enabled, &Length );

                if (Result == ERROR_SUCCESS) {
                    // If we are not currently in there, let add ourselves
                    if (!strstr(Enabled, ImageFileName)) {
                        //Watch for a trailing ';'
                        if (Enabled[strlen(Enabled) - 1] != ';')
                            strcat(Enabled, ";");

                        strcat(Enabled, ImageFileName);

                        Result = RegSetValueEx( hKey,
                                                "USTEnabled",
                                                0,
                                                REG_SZ,
                                                (PBYTE)Enabled,
                                                (ULONG)(strlen(Enabled) + 1));
                    }
                }

                free(Enabled);
            } // if enabled
        } // Result == ERROR_SUCCESS on RegQueryValue
        else if (Result == ERROR_FILE_NOT_FOUND) {
                // Key doesnt currently exist so lets just set it.
                Result = RegSetValueEx( hKey,
                                        "USTEnabled",
                                        0,
                                        REG_SZ,
                                        (PBYTE)ImageFileName,
                                        (ULONG)(strlen(ImageFileName) + 1));
        } // Result == ERROR_FILE_NOT_FOUND on RegQueryValue

        RegCloseKey( hKey );
    } // Result == ERROR_SUCCESS on RegCreateKeyEx

    // Did we succeed or not
    if (Result != ERROR_SUCCESS) {
        MessageBox( hwndMain,
                    "Failure adding or accessing User Stack Trace Registry Key",
                    ImageFileName,
                    MB_OK
                  );

        return FALSE;
    }

    return TRUE;
}

BOOLEAN
DelImageNameFromUSTString(
    PCHAR ImageFileName
    )
{
    CHAR *Enabled = NULL;
    CHAR *NameStart = NULL, *NameEnd = NULL;
    HKEY hKey;
    DWORD Result;
    DWORD Length;

    if (strlen( ImageFileName ) == 0)
        return FALSE;

    // Open the Key
    Result = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
                            "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options",
                            0,
                            NULL,
                            REG_OPTION_NON_VOLATILE,
                            KEY_ALL_ACCESS,
                            NULL,
                            &hKey,
                            NULL
                            );

    if (Result == ERROR_SUCCESS) {
        // Get the current length of the registry key
        Result = RegQueryValueEx( hKey, "USTEnabled", NULL, NULL, NULL, &Length );

        if (Result == ERROR_SUCCESS) {
            if (Length != 0) {
                 // Get a buffer big enough for current key
                Enabled = (PCHAR)malloc(Length);
                if (Enabled) {
                    // Get the current key value
                    Result = RegQueryValueEx( hKey, "USTEnabled", NULL, NULL, (PBYTE)Enabled, &Length );

                    if (Result == ERROR_SUCCESS) {

                        // If we are currently in there, delete ourselves
                        NameStart = strstr(Enabled, ImageFileName);

                        if (NameStart) {

                            NameEnd = NameStart + strlen(ImageFileName);

                            if (*NameEnd == ';'){
                                NameEnd++;
                                strcpy(NameStart, NameEnd);
                            }
                            else
                                *NameStart = '\0';

                            //Knock off any trailing ';'
                            if (Enabled[strlen(Enabled) - 1] == ';')
                                Enabled[strlen(Enabled) - 1] = '\0';

                            if (strlen(Enabled)) {
                                Result = RegSetValueEx( hKey,
                                                        "USTEnabled",
                                                        0,
                                                        REG_SZ,
                                                        (PBYTE)Enabled,
                                                        (ULONG)(strlen(Enabled) + 1));
                            }
                            else{
                                Result = RegDeleteValue( hKey, "USTEnabled");
                            }
                        }
                    }

                    free(Enabled);
                }
            }
        }
        else if (Result == ERROR_FILE_NOT_FOUND) {
            // This is a case where the registry key does not already exist
            Result = ERROR_SUCCESS;
        }
        RegCloseKey( hKey );
    }

    // Did we succeed or not
    if (Result != ERROR_SUCCESS) {
        MessageBox( hwndMain,
                    "Failure accessing or deleting User Stack Trace Registry Key",
                    ImageFileName,
                    MB_OK
                  );

        return FALSE;
    }

    return TRUE;
}

BOOLEAN
SetKernelModeFlags(
    DWORD GFlags
    )
{
    NTSTATUS Status;
    SYSTEM_FLAGS_INFORMATION SystemInformation;

    if (!EnableDebugPrivilege()) {
        MessageBox( hwndMain, "Access Denied", "Unable to enable debug privilege", MB_OK );
        ExitProcess( 0 );
        }

    SystemInformation.Flags = GFlags;
    Status = NtSetSystemInformation( SystemFlagsInformation,
                                     &SystemInformation,
                                     sizeof( SystemInformation )
                                   );
    if (!NT_SUCCESS( Status )) {
        MessageBox( hwndMain, "Value Error", "Kernel Mode Flags", MB_OK );
        ExitProcess( 0 );
        }

    LastSetFlags = GFlags;
    return TRUE;
}

DWORD
GetImageFileNameFlags(
    PCHAR ImageFileName
    )
{
    CHAR Buffer[ MAX_PATH ];
    CHAR RegKey[ MAX_PATH ];
    DWORD Length = MAX_PATH;
    DWORD GFlags;
    HKEY hKey;

    GFlags = 0;
    if (strlen( ImageFileName ) != 0) {
        sprintf( RegKey,
                 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
                 ImageFileName
               );

        if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, RegKey, 0, KEY_READ, &hKey) == ERROR_SUCCESS ) {
            if (RegQueryValueEx( hKey, "GlobalFlag", NULL, NULL, (PBYTE)Buffer, &Length ) == ERROR_SUCCESS ) {
                RtlCharToInteger( Buffer, 0, &GFlags );
                }

            RegCloseKey( hKey );
            }

        }

    return GFlags;
}

BOOL
GetImageFileNameDebugger(
    PCHAR ImageFileName,
    PCHAR Debugger
    )
{
    CHAR RegKey[ MAX_PATH ];
    DWORD Length = MAX_PATH;
    DWORD GFlags;
    HKEY hKey;
    BOOL Success = FALSE;

    GFlags = 0;
    if (strlen( ImageFileName ) != 0) {
        sprintf( RegKey,
                 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
                 ImageFileName
               );

        if (RegOpenKeyEx( HKEY_LOCAL_MACHINE, RegKey, 0, KEY_READ, &hKey) == ERROR_SUCCESS ) {

            if (RegQueryValueEx( hKey, "Debugger", NULL, NULL, (PBYTE)Debugger, &Length ) == ERROR_SUCCESS ) {
                Success = TRUE ;
                }

            RegCloseKey( hKey );
            }

        }

    return Success ;
}


BOOLEAN
SetImageFileNameFlags(
    PCHAR ImageFileName,
    DWORD GFlags
    )
{
    CHAR Buffer[ MAX_PATH ];
    CHAR RegKey[ MAX_PATH ];
    HKEY hKey;
    DWORD Result;
    DWORD Length;
    DWORD Disposition;

    if (strlen( ImageFileName ) != 0) {

        sprintf( RegKey,
            "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
            ImageFileName
            );

        Result = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
            RegKey,
            0,
            NULL,
            REG_OPTION_NON_VOLATILE,
            KEY_ALL_ACCESS,
            NULL,
            &hKey,
            &Disposition
            );

        if (Result == ERROR_SUCCESS) {
            if (GFlags == (DWORD)-1) {
                Result = RegDeleteValue( hKey,
                    "GlobalFlag"
                    );
                DelImageNameFromUSTString(ImageFileName);
            }
            else {
                Length = sprintf( Buffer, "0x%08x", GFlags ) + 1;
                Result = RegSetValueEx( hKey,
                    "GlobalFlag",
                    0,
                    REG_SZ,
                    (PBYTE)Buffer,
                    Length
                    );

                if (GFlags&FLG_USER_STACK_TRACE_DB)
                    AddImageNameToUSTString(ImageFileName);
                else
                    DelImageNameFromUSTString(ImageFileName);

                //
                // If we enable page heap for a single application
                // then we will avoid default behavior which is
                // page heap light (only normal allocations) and
                // we will enable the page heap full power.
                // Note that we do not do this for system wide
                // settings because this will make the machine
                // unbootable.
                //

                if ((GFlags & FLG_HEAP_PAGE_ALLOCS)) {

                    Length = sprintf( Buffer, "0x%08x", 0x03 ) + 1;

                    Result = RegSetValueEx(
                        hKey,
                        "PageHeapFlags",
                        0,
                        REG_SZ,
                        (PBYTE)Buffer,
                        Length
                        );
                }
            }

            RegCloseKey( hKey );
        }

        if (Result != ERROR_SUCCESS) {
            MessageBox( hwndMain,
                (GFlags == (DWORD)-1) ?
                "Failed to delete registry value" :
            "Failed to set registry value",
                ImageFileName,
                MB_OK
                );
            return FALSE;
        }

        LastSetFlags = GFlags;
        return TRUE;
    }

    return FALSE;
}


BOOLEAN
SetImageFileNameDebugger(
    PCHAR ImageFileName,
    PCHAR Debugger
    )
{
    CHAR RegKey[ MAX_PATH ];
    HKEY hKey;
    DWORD Result;
    DWORD Disposition;

    if (strlen( ImageFileName ) != 0) {

        sprintf( RegKey,
                 "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
                 ImageFileName
               );

        Result = RegCreateKeyEx( HKEY_LOCAL_MACHINE,
                                 RegKey,
                                 0,
                                 NULL,
                                 REG_OPTION_NON_VOLATILE,
                                 KEY_ALL_ACCESS,
                                 NULL,
                                 &hKey,
                                 &Disposition
                               );

        if (Result == ERROR_SUCCESS) {
            if ( *Debugger  )
            {
                Result = RegSetValueEx( hKey,
                                        "Debugger",
                                        0,
                                        REG_SZ,
                                        (PBYTE)Debugger,
                                        (ULONG)(strlen( Debugger ) + 1));

            }
            else
            {
                Result = RegDeleteValue( hKey, "Debugger" );
            }

            RegCloseKey( hKey );
            }

        if (Result != ERROR_SUCCESS) {
            MessageBox( hwndMain,
                        ( *Debugger ) ?
                            "Failed to delete registry value" :
                            "Failed to set registry value",
                        ImageFileName,
                        MB_OK
                      );
            return FALSE;
            }

        return TRUE;
        }

    return FALSE;
}


BOOLEAN fRegistrySettings;
BOOLEAN fKernelSettings;
BOOLEAN fImageFileSettings;
BOOLEAN fDisplaySettings;
BOOLEAN fLaunchCommand;
BOOLEAN fFlushImageSettings;
PUCHAR TargetImageFileName;
DWORD GlobalFlagMask;
DWORD GlobalFlagSetting;
DWORD OldGlobalFlags;
DWORD NewGlobalFlags;
DWORD NewGlobalFlagsValidMask;
DWORD NewGlobalFlagsIgnored;

void
DisplayFlags(
    PCHAR Msg,
    DWORD Flags,
    DWORD FlagsIgnored
    )
{
    int i;

    if (Flags == 0xFFFFFFFF) {
        printf( "No %s\n", Msg );
        return;
    }

    printf( "Current %s are: %08x\n", Msg, Flags );
    for (i=0; i<32; i++) {
        if (GlobalFlagInfo[i].Abbreviation != NULL &&
            (Flags & GlobalFlagInfo[i].Flag)
            ) {

            if (_stricmp(GlobalFlagInfo[i].Abbreviation, "hpa") == 0) {

                printf( "    %s - %s\n", GlobalFlagInfo[i].Abbreviation, "Enable page heap");
            }
            else {

                printf( "    %s - %s\n", GlobalFlagInfo[i].Abbreviation, GlobalFlagInfo[i].Description );
            }
        }
    }

    if (FlagsIgnored) {
        printf( "Following settings were ignored: %08x\n", FlagsIgnored );
        for (i=0; i<32; i++) {
            if (GlobalFlagInfo[i].Abbreviation != NULL &&
                (FlagsIgnored & GlobalFlagInfo[i].Flag)
                ) {

                if (_stricmp(GlobalFlagInfo[i].Abbreviation, "hpa") == 0) {

                    printf( "    %s - %s\n", GlobalFlagInfo[i].Abbreviation, "Enable page heap");
                }
                else {

                    printf( "    %s - %s\n", GlobalFlagInfo[i].Abbreviation, GlobalFlagInfo[i].Description );
                }
            }
        }
    }
}


BOOL
IsCmdlineOption (
    PCHAR Option,
    PCHAR Name,
    PCHAR NameEx
    )
{
    if (_stricmp (Option, Name) == 0 || _stricmp (Option, NameEx) == 0) {
        return TRUE;
    }
    else {
        return FALSE;
    }
}

int
__cdecl
main(
    int argc,
    char **argv
    )
{
    MSG msg;
    CHAR c;
    PCHAR s;
    BOOLEAN fUsage, fExpectingFlags;
    ULONG i;
    CHAR Settings[ 2*MAX_PATH ];

    OSVERSIONINFO VersionInfo;
    VersionInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO );
    GetVersionEx( &VersionInfo );

    //
    // if the machine is running XP SP1+ or .NET server, the
    // pool tagging will always be on. 
    //
    if ( VersionInfo.dwMajorVersion >= 5 &&
            VersionInfo.dwMinorVersion >= 1 ){

        OSVERSIONINFOEX VersionInfoEx;
        VersionInfoEx.dwOSVersionInfoSize = sizeof( OSVERSIONINFOEX );

        GetVersionEx( (LPOSVERSIONINFO) &VersionInfoEx );

        if ( VersionInfoEx.wProductType != VER_NT_WORKSTATION ){
            PoolTaggingAlwaysOn = TRUE;
        }         
    }
    	
#if defined(_X86_)
    if ( VersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT ) {
        MessageBox( NULL,
            "Global flags only runs on Windows NT and Windows 2000.  The glfags command was ignored.",
            "Global Flags Error",
            0 );
        exit(0);
    }
    else {
        HMODULE hDll;
        hDll = GetModuleHandle("ntdll");
        if (hDll != NULL) {
            pRtlIntegerToChar = ( PRTLINTEGERTOCHAR )
            GetProcAddress(
                hDll,
                "RtlIntegerToChar"
                );
            pNtQueryInformationProcess = ( PNTQUERYINFORMATIONPROCESS )
            GetProcAddress(
                hDll,
                "NtQueryInformationProcess"
                );
            pRtlCharToInteger = ( PRTLCHARTOINTEGER )
            GetProcAddress(
                hDll,
                "RtlCharToInteger"
                );
            pNtSetSystemInformation = ( PNTSETSYSTEMINFORMATION )
            GetProcAddress(
                hDll,
                "NtSetSystemInformation"
                );
            pNtQuerySystemInformation = ( PNTQUERYSYSTEMINFORMATION )
            GetProcAddress(
                hDll,
                "NtQuerySystemInformation"
                );
        }
    }
#endif

    //
    // Check if we need to redirect the whole command line to the page heap
    // command line parser.
    //

    if (argc >= 2 && IsCmdlineOption (argv[1], "/p", "-p")) {

        PageHeapMain (argc - 1, argv + 1);
        exit(0);
    }
                                                                
    //
    // Check forst for `-i APP -tracedb SIZE' option
    //

    if (argc == 5 && 
        IsCmdlineOption (argv[3], "/tracedb", "-tracedb") &&
        IsCmdlineOption (argv[1], "/i", "-i")) {
        
        ULONG RealSize;

        if (GflagsSetTraceDatabaseSize (argv[2], atoi (argv[4]), &RealSize) == FALSE) {
            
            printf("Failed to set the trace database size for `%s' \n", argv[2]);
            printf("The user mode stack trace database flag (+ust) "
                   "must be enabled before setting /tracedb .\n");
            exit(5);
        }
        else {

            if (RealSize > 0) {
                printf("Trace database size for `%s' set to %u Mb.\n", argv[2], RealSize);
            }
            else {
                printf("Will use default size for the trace database. \n");
            }
            exit(0);
        }
    }

    //
    // Continue ...
    //

    hwndMain = NULL;
    fUsage = FALSE;
    fExpectingFlags = FALSE;
    GlobalFlagMask = 0xFFFFFFFF;
    GlobalFlagSetting = 0;
    while (--argc) {
        s = *++argv;
        if (!fExpectingFlags && (*s == '-' || *s == '/')) {
            while (*++s) {
                c = (char)tolower(*s);
                switch (c) {
                    case 'r':
                    case 'k':
                    case 'i':
                        if (fRegistrySettings || fKernelSettings || fImageFileSettings) {
                            fprintf( stderr, "GFLAG: may only specify one of -r, -k or -i\n" );
                            fUsage = TRUE;
                        }
                        else {
                            fExpectingFlags = TRUE;
                            fDisplaySettings = TRUE;
                            if (c == 'r') {
                                fRegistrySettings = TRUE;
                                OldGlobalFlags = GetSystemRegistryFlags();
                                NewGlobalFlagsValidMask = GFLGS_VALID_SYSTEM_REGISTRY_FLAGS;
                                strcpy( Settings, "Boot Registry Settings" );
                            }
                            else
                                if (c == 'k') {
                                fKernelSettings = TRUE;
                                NewGlobalFlagsValidMask = GFLGS_VALID_KERNEL_MODE_FLAGS;
                                OldGlobalFlags = GetKernelModeFlags();
                                strcpy( Settings, "Running Kernel Settings" );
                            }
                            else {
                                fImageFileSettings = TRUE;
                                NewGlobalFlagsValidMask = GFLGS_VALID_IMAGE_FILE_NAME_FLAGS;
                                if (!--argc) {
                                    fprintf( stderr, "GFLAGS: ImageFileName missing after -i switch\n" );
                                    fUsage = TRUE;
                                    exit( 0 ); // 179741 - JHH
                                }
                                else {
                                    TargetImageFileName = (PUCHAR)(*++argv);
                                    OldGlobalFlags = GetImageFileNameFlags( (PCHAR)TargetImageFileName );
                                    sprintf( Settings, "Registry Settings for %s executable", TargetImageFileName );
                                }
                            }
                        }
                        break;

                    case 'l':
                        fLaunchCommand = TRUE;
                        fExpectingFlags = TRUE;
                        break;

                    default:
                        fUsage = TRUE;
                        break;
                }
            }
        }
        else {
            if (fExpectingFlags) {

                fDisplaySettings = FALSE;

                if (*s == '+' || *s == '-') {

                    if (strlen(s+1) == 3) {

                        for (i = 0; i < 32; i += 1) {

                            if ((NewGlobalFlagsValidMask & GlobalFlagInfo[i].Flag) &&
                                (GlobalFlagInfo[i].Abbreviation != NULL) &&
                                _stricmp( GlobalFlagInfo[i].Abbreviation, s+1 ) == NULL) {

                                if (fKernelSettings) {

                                    if (_stricmp(GlobalFlagInfo[i].Abbreviation, "ptg") == NULL) {
                                        fprintf (stderr, 
                                                 "Ignoring `ptg' flag. It can be used only with registry "
                                                 "settings (`-r') because it requires a reboot.\n");
                                        continue;
                                    }

                                    if (_stricmp(GlobalFlagInfo[i].Abbreviation, "kst") == NULL) {
                                        fprintf (stderr, 
                                                 "Ignoring `kst' flag. It can be used only with registry "
                                                 "settings (`-r') because it requires a reboot.\n");
                                        continue;
                                    }
                                }

                                if (*s == '-') {
                                    GlobalFlagMask &= ~GlobalFlagInfo[i].Flag;
                                }
                                else {
                                    GlobalFlagSetting |= GlobalFlagInfo[i].Flag;
                                }

                                s += 4;
                                break;
                            }
                        }
                    }

                    if (*s != '\0') {
                        if (*s++ == '-') {
                            GlobalFlagMask &= ~strtoul( s, &s, 16 );
                        }
                        else {
                            GlobalFlagSetting |= strtoul( s, &s, 16 );
                        }
                    }
                }
                else {
                    fExpectingFlags = FALSE;
                    GlobalFlagSetting = strtoul( s, &s, 16 );
                }

                if (fLaunchCommand) {
                    exit( 0 );
                }

                if (fImageFileSettings && OldGlobalFlags == 0xFFFFFFFF) {
                    OldGlobalFlags = 0;
                }
            }
            else {
                fprintf( stderr, "GFLAGS: Unexpected argument - '%s'\n", s );
                fUsage = TRUE;
            }
        }
    }

    if (fUsage) {
        
        fputs(GflagsHelpText,
              stderr);

        for (i=0; i<32; i++) {

            if (GlobalFlagInfo[i].Abbreviation != NULL) {

                if (_stricmp(GlobalFlagInfo[i].Abbreviation, "hpa") == 0) {

                    fprintf( stderr, "    %s - %s\n",
                        GlobalFlagInfo[i].Abbreviation,
                        "Enable page heap");
                } 
                else {

                    fprintf( stderr, "    %s - %s\n",
                        GlobalFlagInfo[i].Abbreviation,
                        GlobalFlagInfo[i].Description);
                }
            }
        }

        fprintf( stderr, "\nAll images with ust enabled can be accessed in the\n" );
        fprintf( stderr, "USTEnabled key under 'Image File Options'.\n" );
        exit( 1 );
    }

    if ( PoolTaggingAlwaysOn && !fImageFileSettings ){
        for (i = 0; i < 32; i += 1) {
            if ( (GlobalFlagInfo[i].Abbreviation != NULL ) &&
                (_stricmp(GlobalFlagInfo[i].Abbreviation, "ptg" ) == NULL ) ){
                   
                    PoolTagEnabledFlag = GlobalFlagInfo[i].Flag;
                    break;
            }
        }

        if ( (~GlobalFlagMask & PoolTagEnabledFlag) ||
            (GlobalFlagSetting & PoolTagEnabledFlag ) ) {

            fprintf( stderr, 
                "\nIgnoring `ptg' flag. Pool Tagging is always enabled on this operating system.\n");

            exit(1);    
        
        }
    }
    	
    NewGlobalFlags = (OldGlobalFlags & GlobalFlagMask) | GlobalFlagSetting;
    if (!fImageFileSettings || NewGlobalFlags != 0xFFFFFFFF) {
        NewGlobalFlagsIgnored = ~NewGlobalFlagsValidMask & NewGlobalFlags;
        NewGlobalFlags &= NewGlobalFlagsValidMask;
    }

    if (fDisplaySettings) {
        DisplayFlags( Settings, NewGlobalFlags, NewGlobalFlagsIgnored );
        exit( 0 );
    }

    if (fRegistrySettings) {
        SetSystemRegistryFlags( NewGlobalFlags,
            0,
            SPECIAL_POOL_OVERRUNS_CHECK_FORWARD
            );
        DisplayFlags( Settings, NewGlobalFlags, NewGlobalFlagsIgnored );
        exit( 0 );
    }

    else
        if (fKernelSettings) {
        SetKernelModeFlags( NewGlobalFlags );
        DisplayFlags( Settings, NewGlobalFlags, NewGlobalFlagsIgnored );
        exit( 0 );
    }
    else
        if (fImageFileSettings) {
        SetImageFileNameFlags( (PCHAR)TargetImageFileName, NewGlobalFlags );
        DisplayFlags( Settings, NewGlobalFlags, NewGlobalFlagsIgnored );
        exit( 0 );
    }

    CreateDialog( NULL,
        (LPSTR)DID_GFLAGS,
        NULL,
        MainWndProc
        );
    if (!hwndMain) {
        MessageBox( hwndMain, "Main Error", "Cant create dialog", MB_OK );
        ExitProcess( 0 );
    }

    while (GetMessage( &msg, 0, 0, 0 )) {
        if (!IsDialogMessage( hwndMain, &msg )) {
            DispatchMessage( &msg );
        }
    }

    return 0;
}


VOID
SetCheckBoxesFromFlags(
    DWORD GFlags,
    DWORD ValidFlags
    )
{
    int iBit;

    GFlags &= ValidFlags;
    LastSetFlags = GFlags;
    for (iBit=0; iBit < 32; iBit++) {
        CheckDlgButton( hwndMain,
                        ID_FLAG_1 + iBit,
                        (GFlags & (1 << iBit)) ? 1 : 0
                      );

        ShowWindow( GetDlgItem( hwndMain, ID_FLAG_1 + iBit ),
                    (ValidFlags & (1 << iBit)) ? SW_SHOWNORMAL : SW_HIDE
                  );
        }
}

DWORD
GetFlagsFromCheckBoxes( VOID )
{
    DWORD GFlags;
    int iBit;

    GFlags = 0;
    for (iBit=0; iBit < 32; iBit++) {
        if (IsDlgButtonChecked( hwndMain, ID_FLAG_1 + iBit )) {
            GFlags |= (1 << iBit);
            }
        }

    return GFlags;
}


VOID
DoLaunch(
    PCHAR CommandLine,
    DWORD GFlags
    )
{
    STARTUPINFO StartupInfo;
    PROCESS_INFORMATION ProcessInformation;
    NTSTATUS Status;
    PROCESS_BASIC_INFORMATION BasicInformation;
    BOOLEAN ReadImageFileExecOptions;

    memset( &StartupInfo, 0, sizeof( StartupInfo ) );
    StartupInfo.cb = sizeof( StartupInfo );
    if (CreateProcess( NULL,
                       CommandLine,
                       NULL,
                       NULL,
                       FALSE,
                       CREATE_SUSPENDED,
                       NULL,
                       NULL,
                       &StartupInfo,
                       &ProcessInformation
                     )
       ) {
        Status = NtQueryInformationProcess( ProcessInformation.hProcess,
                                            ProcessBasicInformation,
                                            &BasicInformation,
                                            sizeof( BasicInformation ),
                                            NULL
                                          );
        if (NT_SUCCESS( Status )) {
            ReadImageFileExecOptions = TRUE;
            if (!WriteProcessMemory( ProcessInformation.hProcess,
                                     &BasicInformation.PebBaseAddress->ReadImageFileExecOptions,
                                     &ReadImageFileExecOptions,
                                     sizeof( ReadImageFileExecOptions ),
                                     NULL
                                   ) ||
                !WriteProcessMemory( ProcessInformation.hProcess,
                                     &BasicInformation.PebBaseAddress->NtGlobalFlag,
                                     &GFlags,
                                     sizeof( GFlags ),
                                     NULL
                                   )
               ) {
                Status = STATUS_UNSUCCESSFUL;
                }
            }


        if (!NT_SUCCESS( Status )) {
            MessageBox( hwndMain,
                        "Launch Command Line",
                        "Unable to pass flags to process - terminating",
                        MB_OK
                      );
            TerminateProcess( ProcessInformation.hProcess, 1 );
            }

        ResumeThread( ProcessInformation.hThread );
        CloseHandle( ProcessInformation.hThread );
        MsgWaitForMultipleObjects( 1,
                                   &ProcessInformation.hProcess,
                                   FALSE,
                                   NMPWAIT_WAIT_FOREVER,
                                   QS_ALLINPUT
                                 );
        CloseHandle( ProcessInformation.hProcess );
        }
    else {
        MessageBox( hwndMain, "Launch Command Line", "Unable to create process", MB_OK );
        }

    return;
}


DWORD LastRadioButtonId;
DWORD SpecialPoolModeId;
DWORD SpecialPoolOverrunsId;

BOOLEAN
CheckSpecialPoolTagItem(
    HWND hwnd,
    BOOLEAN ForApply
    )
{
    DWORD NumChars;
    DWORD i;
    BOOLEAN IsIllegal = FALSE;

    NumChars = GetDlgItemText( hwnd, ID_SPECIAL_POOL_TAG, SpecialPoolRenderBuffer, sizeof( SpecialPoolRenderBuffer ));

    if (NumChars != 0) {

        if (SpecialPoolModeId == ID_SPECIAL_POOL_IS_NUMBER) {

            //
            //  Check for illegal characters.
            //

            if (NumChars > 8) {

                IsIllegal = TRUE;

            } else {

                for (i = 0; i < NumChars; i++) {

                    if (!((SpecialPoolRenderBuffer[i] >= '0' &&
                           SpecialPoolRenderBuffer[i] <= '9') ||

                          (SpecialPoolRenderBuffer[i] >= 'a' &&
                           SpecialPoolRenderBuffer[i] <= 'f') ||

                          (SpecialPoolRenderBuffer[i] >= 'A' &&
                           SpecialPoolRenderBuffer[i] <= 'F'))) {

                        IsIllegal = TRUE;
                        break;
                    }
                }
            }

        } else {

            //
            //  Check for too many characters.
            //

            if (NumChars > sizeof(DWORD)) {

                IsIllegal = TRUE;
            }

            //
            //  We check a few more things when the user is really writing back.
            //

            if (!IsIllegal && ForApply) {

                //
                //  If this is not four characters and does not end in a '*',
                //  it is usually the case that the user really wanted a space
                //  at the end of the tag 'Gh1 ', not 'Gh1'.  Make sure they
                //  get a little feedback.
                //

                if (NumChars != sizeof(DWORD)  && SpecialPoolRenderBuffer[NumChars - 1] != '*') {

                    MessageBox( hwnd,
                                "The specified tag is less than 4 characters, but most\n"
                                "are really padded out with spaces.  Please check and\n"
                                "add spaces if neccesary.",
                                "Possibly ambiguous special pool tag",
                                MB_OK );

                }
            }
        }
    }

    if (IsIllegal) {

        MessageBox( hwnd, (SpecialPoolModeId == ID_SPECIAL_POOL_IS_NUMBER ? "Must be a hexadecimal DWORD" :
                                                                            "Must be at most 4 characters"),
                    "Illegal characters in special pool tag",
                    MB_OK );
    }

    return !IsIllegal;
}

DWORD
GetSpecialPoolTagItem(
    HWND hwnd
    )
{
    DWORD NumChars;
    DWORD Tag = 0;

    UNREFERENCED_PARAMETER(hwnd);

    //
    //  We assume that the field is has been retrieved and checked.
    //

    NumChars = (ULONG)strlen( SpecialPoolRenderBuffer );

    if (NumChars != 0) {

        if (SpecialPoolModeId == ID_SPECIAL_POOL_IS_NUMBER) {

            RtlCharToInteger( SpecialPoolRenderBuffer, 16, &Tag );

        } else {

            //
            //  Just drop the bytes into the DWORD - endianess is correct as is.
            //

            RtlCopyMemory( &Tag,
                           SpecialPoolRenderBuffer,
                           NumChars );
        }
    }

    return Tag;
}

DWORD
GetSpecialPoolOverrunsItem(
    HWND hwnd
    )
{
    UNREFERENCED_PARAMETER(hwnd);
    
    switch (SpecialPoolOverrunsId) {

        case ID_SPECIAL_POOL_VERIFY_END: return SPECIAL_POOL_OVERRUNS_CHECK_FORWARD;
        case ID_SPECIAL_POOL_VERIFY_START: return SPECIAL_POOL_OVERRUNS_CHECK_BACKWARD;

        default: return SPECIAL_POOL_OVERRUNS_CHECK_FORWARD;
    }
}

VOID
ReRenderSpecialPoolTagItem(
    HWND hwnd
    )
{
    DWORD NumChars;
    DWORD Tag = 0;

    //
    //  We assume that the field is has been retrieved and checked.
    //

    NumChars = (ULONG)strlen( SpecialPoolRenderBuffer );

    //
    //  Assume that the dialog contents are of the previous mode. Switch it.
    //

    if (NumChars != 0) {

        if (SpecialPoolModeId == ID_SPECIAL_POOL_IS_NUMBER) {

            RtlCopyMemory( &Tag,
                           SpecialPoolRenderBuffer,
                           NumChars );
            RtlIntegerToChar( Tag, 16, sizeof( SpecialPoolRenderBuffer ), SpecialPoolRenderBuffer);

        } else {

            RtlCharToInteger( SpecialPoolRenderBuffer, 16, &Tag );
            RtlCopyMemory( SpecialPoolRenderBuffer,
                           &Tag,
                           sizeof( Tag ));
            SpecialPoolRenderBuffer[sizeof( Tag )] = '\0';
        }
    }

    SetDlgItemText( hwnd, ID_SPECIAL_POOL_TAG, SpecialPoolRenderBuffer );
}

BOOLEAN
CheckForUnsaved(
    HWND hwnd
    )
{
    //
    //  Appropriate to the mode we are leaving, see if there were unsaved changes.
    //  Return TRUE if there are unsaved changes.
    //

    if (GetFlagsFromCheckBoxes() != LastSetFlags ||
           (fFlushImageSettings && (LastRadioButtonId == ID_IMAGE_FILE_OPTIONS)) ||
        (LastRadioButtonId == ID_SYSTEM_REGISTRY &&
         (!CheckSpecialPoolTagItem( hwnd, FALSE ) ||
          (GetSpecialPoolTagItem( hwnd ) != LastSetSpecialPoolTag) ||
          (GetSpecialPoolOverrunsItem( hwnd ) != LastSetSpecialPoolOverruns)))) {


        if (MessageBox( hwndMain,
                        "You didn't click 'apply' - did you want to discard current changes??",
                        "Warning",
                        MB_YESNO
                        ) == IDNO
            ) {

            return TRUE;
        }
    }

    return FALSE;
}


INT_PTR
APIENTRY
MainWndProc(
    HWND hwnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam
    )
{
    DWORD NewFlags;
    CHAR ImageFileName[ MAX_PATH ];
    CHAR CommandLine[ MAX_PATH ];
    BOOL bCancelDiscard;
    int i;

    UNREFERENCED_PARAMETER(lParam);

    bCancelDiscard = FALSE;

    switch (message) {

        case WM_INITDIALOG:

            hwndMain = hwnd;
            LastRadioButtonId = ID_SYSTEM_REGISTRY;
            CheckRadioButton( hwnd,
                ID_SYSTEM_REGISTRY,
                ID_IMAGE_FILE_OPTIONS,
                LastRadioButtonId
                );

            EnableSetOfControls( hwnd, SpecialPool, TRUE );
            EnableSetOfControls( hwnd, Debugger, FALSE );

            SetCheckBoxesFromFlags( GetSystemRegistryFlags(), GFLGS_VALID_SYSTEM_REGISTRY_FLAGS );

            //
            //  Make a not so wild guess about what kind of tag it is.
            //

            if (LastSetSpecialPoolTag && LastSetSpecialPoolTag < 0x2000) {

                SpecialPoolModeId = ID_SPECIAL_POOL_IS_NUMBER;
                RtlIntegerToChar( LastSetSpecialPoolTag,
                    16,
                    sizeof( SpecialPoolRenderBuffer ),
                    SpecialPoolRenderBuffer );
            }
            else {

                SpecialPoolModeId = ID_SPECIAL_POOL_IS_TEXT;
                RtlCopyMemory( SpecialPoolRenderBuffer,
                    &LastSetSpecialPoolTag,
                    sizeof( LastSetSpecialPoolTag ));
                SpecialPoolRenderBuffer[sizeof(LastSetSpecialPoolTag)] = '\0';
            }

            CheckRadioButton( hwnd,
                ID_SPECIAL_POOL_IS_TEXT,
                ID_SPECIAL_POOL_IS_NUMBER,
                SpecialPoolModeId
                );
            SetDlgItemText( hwnd, ID_SPECIAL_POOL_TAG, SpecialPoolRenderBuffer );

            //
            // Initial state for the special pool overrun radio buttons.
            //

            switch (LastSetSpecialPoolOverruns) {

                case SPECIAL_POOL_OVERRUNS_CHECK_FORWARD:
                    SpecialPoolOverrunsId = ID_SPECIAL_POOL_VERIFY_END;
                    break;

                case SPECIAL_POOL_OVERRUNS_CHECK_BACKWARD:
                    SpecialPoolOverrunsId = ID_SPECIAL_POOL_VERIFY_START;
                    break;

                default:
                    SpecialPoolOverrunsId = ID_SPECIAL_POOL_VERIFY_END;
                    break;
            }

            CheckRadioButton( hwnd,
                ID_SPECIAL_POOL_VERIFY_START,
                ID_SPECIAL_POOL_VERIFY_END,
                SpecialPoolOverrunsId
                );

            if ( PoolTaggingAlwaysOn )
            {
                    //
                    //   on windows XP and above, POOL tagging will always be on.
                    //
                    CheckDlgButton(hwnd, ID_FLAG_11, BST_CHECKED);
                    EnableWindow(GetDlgItem(hwnd, ID_FLAG_11), FALSE);			
            }

            return(TRUE);

        case WM_COMMAND:

            switch ( LOWORD(wParam) ) {

                case ID_LAUNCH:

                    GetDlgItemText( hwnd, ID_COMMAND_LINE, CommandLine, sizeof( CommandLine ) );
                    if (strlen( ImageFileName ) == 0) {
                        MessageBox( hwndMain, "Launch Command Line", "Must fill in command line first", MB_OK );
                        SetFocus( GetDlgItem( hwnd, ID_COMMAND_LINE ) );
                        break;
                    }

                    // fall through

                case ID_APPLY:

                    if (IsDlgButtonChecked( hwnd, ID_SYSTEM_REGISTRY )) {

                        //
                        // System wide settings
                        //

                        if (CheckSpecialPoolTagItem( hwnd, TRUE )) {

                            NewFlags = GetFlagsFromCheckBoxes();

                            SetSystemRegistryFlags(
                                NewFlags,
                                GetSpecialPoolTagItem( hwnd ),
                                GetSpecialPoolOverrunsItem (hwnd));
                        }
                    }
                    else if (IsDlgButtonChecked( hwnd, ID_KERNEL_MODE )) {

                        //
                        // Kernel mode settings
                        //
                        // N.B. This will set flags on the fly. It does not touch
                        // the registry and does not require a reboot.
                        //

                        NewFlags = GetFlagsFromCheckBoxes();

                        SetKernelModeFlags( NewFlags );
                    }
                    else if (IsDlgButtonChecked( hwnd, ID_IMAGE_FILE_OPTIONS )) {

                        //
                        // Application specific settings
                        //

                        GetDlgItemText( hwnd, ID_IMAGE_FILE_NAME, ImageFileName, sizeof( ImageFileName ) );
                        if (strlen( ImageFileName ) == 0) {
                            MessageBox( hwnd, "Missing Image File Name", "Must set image file name", MB_OK );
                            SetFocus( GetDlgItem( hwnd, ID_IMAGE_FILE_NAME ) );
                            break;
                        }

                        SetImageFileNameFlags( ImageFileName, GetFlagsFromCheckBoxes() );
                        if ( fFlushImageSettings ) {

                            GetDlgItemText( hwnd, ID_IMAGE_DEBUGGER_VALUE, LastDebuggerValue, MAX_PATH );

                            SetImageFileNameDebugger( ImageFileName, LastDebuggerValue );

                            fFlushImageSettings = FALSE ;

                        }
                    }

                    if (LOWORD(wParam) == ID_LAUNCH) {
                        DoLaunch( CommandLine,
                            GetFlagsFromCheckBoxes()
                            );
                    }
                    break;

                case IDOK:
                    if (CheckForUnsaved( hwnd )) {
                        break;
                    }

                    // fall through

                case IDCANCEL:
                    PostQuitMessage(0);
                    DestroyWindow( hwnd );
                    break;

                case ID_SPECIAL_POOL_IS_TEXT:
                case ID_SPECIAL_POOL_IS_NUMBER:

                    if (CheckSpecialPoolTagItem( hwnd, FALSE )) {

                        if (LOWORD(wParam) != SpecialPoolModeId) {

                            SpecialPoolModeId = LOWORD(wParam);
                            CheckRadioButton( hwnd,
                                ID_SPECIAL_POOL_IS_TEXT,
                                ID_SPECIAL_POOL_IS_NUMBER,
                                SpecialPoolModeId
                                );

                            ReRenderSpecialPoolTagItem( hwnd );
                        }
                    }
                    else {

                        //
                        //  Always treat this as a cancel.
                        //

                        bCancelDiscard = TRUE;
                    }

                    break;

                case ID_SPECIAL_POOL_VERIFY_START:
                case ID_SPECIAL_POOL_VERIFY_END:

                    if (LOWORD(wParam) != SpecialPoolOverrunsId) {

                        SpecialPoolOverrunsId = LOWORD(wParam);
                        CheckRadioButton( hwnd,
                            ID_SPECIAL_POOL_VERIFY_START,
                            ID_SPECIAL_POOL_VERIFY_END,
                            SpecialPoolOverrunsId
                            );
                    }

                    break;

                case ID_IMAGE_DEBUGGER_BUTTON:
                    if (IsDlgButtonChecked( hwnd, ID_IMAGE_DEBUGGER_BUTTON ) == BST_CHECKED ) {
                        EnableWindow( GetDlgItem( hwnd, ID_IMAGE_DEBUGGER_VALUE ), TRUE );

                        GetDlgItemText( hwnd, ID_IMAGE_FILE_NAME, ImageFileName, MAX_PATH );

                        for ( i = 0 ; i < sizeof( SystemProcesses ) / sizeof( PCHAR ) ; i++ ) {
                            if (_stricmp( ImageFileName, SystemProcesses[i] ) == 0 ) {
                                SetDlgItemText( hwnd, ID_IMAGE_DEBUGGER_VALUE, "ntsd -d -g -G" );
                                break;
                            }
                        }

                    }
                    else {
                        SetDlgItemText( hwnd, ID_IMAGE_DEBUGGER_VALUE, "" );
                        EnableWindow( GetDlgItem( hwnd, ID_IMAGE_DEBUGGER_VALUE ), FALSE );
                    }
                    fFlushImageSettings = TRUE ;
                    break;

                case ID_SYSTEM_REGISTRY:
                    if (CheckForUnsaved( hwnd )) {
                        bCancelDiscard = TRUE;
                        break;
                    }

                    LastRadioButtonId = ID_SYSTEM_REGISTRY;
                    SetCheckBoxesFromFlags( GetSystemRegistryFlags(), GFLGS_VALID_SYSTEM_REGISTRY_FLAGS );
                    EnableSetOfControls( hwnd, SpecialPool, TRUE );
                    EnableSetOfControls( hwnd, Debugger, FALSE );


                    break;

                case ID_KERNEL_MODE:
                    if (CheckForUnsaved( hwnd )) {
                        bCancelDiscard = TRUE;
                        break;
                    }

                    LastRadioButtonId = ID_KERNEL_MODE;
                    SetCheckBoxesFromFlags( GetKernelModeFlags(), GFLGS_VALID_KERNEL_MODE_FLAGS );
                    EnableSetOfControls( hwnd, SpecialPool, FALSE );
                    EnableSetOfControls( hwnd, Debugger, FALSE );

                    break;

                case ID_IMAGE_FILE_OPTIONS:
                    if (CheckForUnsaved( hwnd )) {
                        bCancelDiscard = TRUE;
                        break;
                    }

                    GetDlgItemText( hwnd, ID_IMAGE_FILE_NAME, ImageFileName, sizeof( ImageFileName ) );
                    if (strlen( ImageFileName ) == 0) {
                        MessageBox( hwndMain, "Image File Name Missing", "Must fill in image file name first", MB_OK );
                        CheckRadioButton( hwnd,
                            ID_SYSTEM_REGISTRY,
                            ID_IMAGE_FILE_OPTIONS,
                            LastRadioButtonId
                            );
                        SetCheckBoxesFromFlags( GetSystemRegistryFlags(), GFLGS_VALID_SYSTEM_REGISTRY_FLAGS );
                        SetFocus( GetDlgItem( hwnd, ID_IMAGE_FILE_NAME ) );
                        break;
                    }
                    else {
                        LastRadioButtonId = ID_IMAGE_FILE_OPTIONS;
                        SetCheckBoxesFromFlags( GetImageFileNameFlags( ImageFileName ),
                            GFLGS_VALID_IMAGE_FILE_NAME_FLAGS
                            );

                        if ( GetImageFileNameDebugger( ImageFileName, LastDebuggerValue ) ) {
                            SetDlgItemText( hwnd, ID_IMAGE_DEBUGGER_VALUE, LastDebuggerValue );
                            CheckDlgButton( hwnd, ID_IMAGE_DEBUGGER_BUTTON, 1 );

                        }

                        EnableSetOfControls( hwnd, SpecialPool, FALSE );
                        EnableSetOfControls( hwnd, Debugger, TRUE );

                    }
                    break;

                default:
                    break;
            }
            break;

        case WM_CLOSE:
            PostQuitMessage(0);
            DestroyWindow( hwnd );
            break;

    }

    if (bCancelDiscard) {

        //
        //  Recheck the right radio buttons 'cause the user didn't
        //  *really* mean it.
        //

        CheckRadioButton( hwnd,
            ID_SYSTEM_REGISTRY,
            ID_IMAGE_FILE_OPTIONS,
            LastRadioButtonId
            );
        CheckRadioButton( hwnd,
            ID_SPECIAL_POOL_IS_TEXT,
            ID_SPECIAL_POOL_IS_NUMBER,
            SpecialPoolModeId
            );

        CheckRadioButton( hwnd,
            ID_SPECIAL_POOL_VERIFY_START,
            ID_SPECIAL_POOL_VERIFY_END,
            SpecialPoolOverrunsId
            );

    }

    return 0;
}


BOOL
EnableDebugPrivilege( VOID )
{
    HANDLE Token = NULL;
    PTOKEN_PRIVILEGES NewPrivileges = NULL;
	ULONG cbNeeded = 0;
    BOOL fRc = FALSE;
	LUID LuidPrivilege = {0};
	DWORD dwError = ERROR_SUCCESS;

    //
    // Make sure we have access to adjust and to get the old token privileges
    //
	fRc = OpenProcessToken(GetCurrentProcess(),
                           TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY,
                           &Token);

	if (!fRc) {

		dwError = GetLastError();
		goto Exit;
	}

    //
    // Initialize the privilege adjustment structure
    //
    fRc = LookupPrivilegeValue( NULL, SE_DEBUG_NAME, &LuidPrivilege );

	if (!fRc) {

		dwError = GetLastError();
		goto Exit;
	}

	//
	// Allocate memory for NewPrivileges
	//
	cbNeeded = sizeof(TOKEN_PRIVILEGES) + 
		       (1 - ANYSIZE_ARRAY) * sizeof(LUID_AND_ATTRIBUTES);

    NewPrivileges = (PTOKEN_PRIVILEGES)HeapAlloc(GetProcessHeap(), 0, cbNeeded);

    if (NewPrivileges == NULL) {

		dwError = ERROR_OUTOFMEMORY;
		fRc = FALSE;
		goto Exit;
	}

    NewPrivileges->PrivilegeCount = 1;
    NewPrivileges->Privileges[0].Luid = LuidPrivilege;
    NewPrivileges->Privileges[0].Attributes = SE_PRIVILEGE_ENABLED;

    //
    // Enable the privilege
    //
    fRc = AdjustTokenPrivileges(Token,
		                        FALSE,
								NewPrivileges,
								0,
                                (PTOKEN_PRIVILEGES)NULL,
								(PDWORD)NULL);

    if (!fRc) {

		dwError = GetLastError();
		goto Exit;
	}

Exit:

	//
	// Cleanup handles, memory, etc. before exiting the function
	//
	if (NULL != Token) {

		CloseHandle(Token);
		Token = NULL;
	}

	if (NULL != NewPrivileges) {

		HeapFree(GetProcessHeap(), 0, NewPrivileges);
		NewPrivileges = NULL;
	}

	SetLastError(dwError);
    return fRc;
}

VOID
CenterDialog( HWND hWndDialog )
{
    RECT rectWindow;
    POINT pointCenter;
    POINT pointNewCornerChild;
    INT nChildWidth;
    INT nChildHeight;
    HWND hWndParent;

    hWndParent = GetParent( hWndDialog );

    //
    // parent window's rectangle
    //

    GetWindowRect( hWndParent, &rectWindow );

    //
    // the center, in screen coordinates
    //

    pointCenter.x = rectWindow.left + ( rectWindow.right - rectWindow.left ) / 2;
    pointCenter.y = rectWindow.top + ( rectWindow.bottom - rectWindow.top ) / 2;

    //
    // chils window's rectangle, in screen coordinates
    //

    GetWindowRect( hWndDialog, &rectWindow );

    nChildWidth = rectWindow.right - rectWindow.left ;
    nChildHeight = rectWindow.bottom - rectWindow.top;

    //
    // the new top-left corner of the child
    //

    pointNewCornerChild.x = pointCenter.x - nChildWidth / 2;
    pointNewCornerChild.y = pointCenter.y - nChildHeight / 2;

    //
    // move the child window
    //

    MoveWindow(
        hWndDialog,
        pointNewCornerChild.x,
        pointNewCornerChild.y,
        nChildWidth,
        nChildHeight,
        TRUE );
}


INT_PTR
APIENTRY
PagedHeapDlgProc(
    HWND hwnd,
    UINT message,
    WPARAM wParam,
    LPARAM lParam
    )
{
    INT_PTR nResult;

    UNREFERENCED_PARAMETER(lParam);

	nResult = FALSE;

    switch ( message ) {

        case WM_INITDIALOG:
			hwndPagedHeapDlg = hwnd;

            //
            // center this dialog
            //

            CenterDialog( hwndPagedHeapDlg );

			break;

        case WM_COMMAND:
            switch( LOWORD(wParam) ) {
                case IDYES:
                    EndDialog( hwndPagedHeapDlg, IDYES );
                    break;

                case IDNO:
                    EndDialog( hwndPagedHeapDlg, IDNO );
                    break;
            }
            break;

        case WM_CLOSE:
        case WM_DESTROY:
        case WM_ENDSESSION:
        case WM_QUIT:
            EndDialog(hwndPagedHeapDlg,IDNO);
            nResult = TRUE;
            break;

        default:
            break;
    }

    return nResult;
}

BOOL
OkToEnablePagedHeap( VOID )
{
    MEMORYSTATUS MemoryStatus;

    GlobalMemoryStatus( &MemoryStatus );

    if( MemoryStatus.dwTotalPhys < 512 * 1024 * 1024 ) {

        //
        // less than 512 Mb of RAM
        //

        return ( DialogBoxParam(
                    NULL,
                    (LPCTSTR)( MAKEINTRESOURCE(DID_PAGED_HEAP_WARNING) ),
                    hwndMain,
                    PagedHeapDlgProc,
                    0 ) == IDYES );
    }

    return TRUE;
}


BOOL
GflagsSetTraceDatabaseSize (
    PCHAR ApplicationName,
    ULONG SizeInMb,
    PULONG RealSize
    )
{
    HKEY ImageKey;
    CHAR ImageKeyName[ MAX_PATH ];
    LONG Result;
    DWORD TraceDatabaseSize;

    *RealSize = 0;

    if (ApplicationName == NULL) {
        return FALSE;
    }

    sprintf (ImageKeyName,
             "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Image File Execution Options\\%s",
             ApplicationName);

    Result = RegOpenKeyEx (HKEY_LOCAL_MACHINE, 
                           ImageKeyName, 
                           0, 
                           KEY_QUERY_VALUE | KEY_SET_VALUE, 
                           &ImageKey);

    if (Result != ERROR_SUCCESS) {
        return FALSE;
    }

    if (SizeInMb == 0) {
        
        Result = RegDeleteValue (ImageKey,
                                 "StackTraceDatabaseSizeInMb");

        if (Result != ERROR_SUCCESS) {
            RegCloseKey (ImageKey);
            return FALSE;
        }
    }
    else {

        if (SizeInMb < 8) {
            
            TraceDatabaseSize = 8;
        } 
        else {

            TraceDatabaseSize = SizeInMb;
        }

        Result = RegSetValueEx (ImageKey,
                                "StackTraceDatabaseSizeInMb",
                                0,
                                REG_DWORD,
                                (PBYTE)(&TraceDatabaseSize),
                                sizeof TraceDatabaseSize);

        if (Result != ERROR_SUCCESS) {
            RegCloseKey (ImageKey);
            return FALSE;
        }

        *RealSize = TraceDatabaseSize;
    }

    RegCloseKey (ImageKey);
    return TRUE;
}