41 files changed, 13257 insertions, 0 deletions

diff --git a/private/sdktools/instaler/compinst.c b/private/sdktools/instaler/compinst.c
new file mode 100644
index 000000000..9c6df1338
--- /dev/null
+++ b/private/sdktools/instaler/compinst.c
@@ -0,0 +1,899 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    showinst.c
+
+Abstract:
+
+    This program compares the actions described by two Installation Modification Log file
+    created by the INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 15-Jan-1996
+
+Revision History:
+
+--*/
+
+#include "instutil.h"
+#include "iml.h"
+
+BOOLEAN VerboseOutput;
+
+BOOLEAN
+CompareIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2
+    );
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    char *s;
+    PWSTR ImlPathAlt = NULL;
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1 = NULL;
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2 = NULL;
+
+    InitCommonCode( "COMPINST",
+                    "InstallationName2 [-v]",
+                    "-v verbose output\n"
+                  );
+    VerboseOutput = FALSE;
+    while (--argc) {
+        s = *++argv;
+        if (*s == '-' || *s == '/') {
+            while (*++s) {
+                switch( tolower( *s ) ) {
+                    case 'v':
+                        VerboseOutput = TRUE;
+                        break;
+                    default:
+                        CommonSwitchProcessing( &argc, &argv, *s );
+                        break;
+                    }
+                }
+            }
+        else
+        if (!CommonArgProcessing( &argc, &argv )) {
+            if (ImlPathAlt != NULL) {
+                Usage( "Too many installation names specified - '%s'", (ULONG)s );
+                }
+
+            ImlPathAlt = FormatImlPath( InstalerDirectory, GetArgAsUnicode( s ) );
+            }
+        }
+
+    if (ImlPath == NULL || ImlPathAlt == NULL) {
+        Usage( "Must specify two installation names to compare", 0 );
+        }
+
+    if (!SetCurrentDirectory( InstalerDirectory )) {
+        FatalError( "Unable to change to '%ws' directory (%u)",
+                    (ULONG)InstalerDirectory,
+                    GetLastError()
+                  );
+        }
+
+    pIml1 = LoadIml( ImlPath );
+    if (pIml1 == NULL) {
+        FatalError( "Unable to load '%ws' (%u)",
+                    (ULONG)ImlPath,
+                    GetLastError()
+                  );
+        }
+
+    pIml2 = LoadIml( ImlPathAlt );
+    if (pIml2 == NULL) {
+        FatalError( "Unable to load '%ws' (%u)",
+                    (ULONG)ImlPathAlt,
+                    GetLastError()
+                  );
+        }
+
+    printf( "Displaying differences between:\n" );
+    printf( "   Installation 1: %ws\n", ImlPath );
+    printf( "   Installation 2: %ws\n", ImlPathAlt );
+    exit( CompareIml( pIml1, pIml2 ) == FALSE );
+    return 0;
+}
+
+typedef struct _IML_GENERIC_RECORD {
+    POFFSET Next;                   // IML_GENERIC_RECORD
+    ULONG Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET Records;                // IML_GENERIC_RECORD
+} IML_GENERIC_RECORD, *PIML_GENERIC_RECORD;
+
+
+typedef
+VOID
+(*PIML_PRINT_RECORD_ROUTINE)(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PIML_GENERIC_RECORD pGeneric,
+    PWSTR Parents[],
+    ULONG Depth,
+    ULONG i
+    );
+
+typedef
+BOOLEAN
+(*PIML_COMPARE_CONTENTS_ROUTINE)(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PIML_GENERIC_RECORD pGeneric1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2,
+    PIML_GENERIC_RECORD pGeneric2,
+    PWSTR Parents[]
+    );
+
+
+PINSTALLATION_MODIFICATION_LOGFILE pSortIml;
+
+int
+_CRTAPI1
+CompareGeneric(
+    const void *Reference1,
+    const void *Reference2
+    )
+{
+    PIML_GENERIC_RECORD p1 = *(PIML_GENERIC_RECORD *)Reference1;
+    PIML_GENERIC_RECORD p2 = *(PIML_GENERIC_RECORD *)Reference2;
+
+    if (p1->Name == 0) {
+        if (p2->Name == 0) {
+            return 0;
+            }
+        else {
+            return -1;
+            }
+        }
+    else
+    if (p2->Name == 0) {
+        return 1;
+        }
+
+    return _wcsicmp( MP( PWSTR, pSortIml, p1->Name ),
+                     MP( PWSTR, pSortIml, p2->Name )
+                   );
+}
+
+
+PIML_GENERIC_RECORD *
+GetSortedGenericListAsArray(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PIML_GENERIC_RECORD pGeneric
+    )
+{
+    PIML_GENERIC_RECORD p, *pp;
+    ULONG n;
+
+    p = pGeneric;
+    n = 1;
+    while (p != NULL) {
+        n += 1;
+        p = MP( PIML_GENERIC_RECORD, pIml, p->Next );
+        }
+
+    pp = HeapAlloc( GetProcessHeap(), 0, n * sizeof( *pp ) );
+    p = pGeneric;
+    n = 0;
+    while (p != NULL) {
+        pp[ n++ ] = p;
+        p = MP( PIML_GENERIC_RECORD, pIml, p->Next );
+        }
+    pp[ n ] = NULL;
+
+    pSortIml = pIml;
+    qsort( (void *)pp, n, sizeof( *pp ), CompareGeneric );
+    pSortIml = NULL;
+    return pp;
+}
+
+BOOLEAN
+CompareGenericIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PIML_GENERIC_RECORD pGeneric1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2,
+    PIML_GENERIC_RECORD pGeneric2,
+    PWSTR Parents[],
+    ULONG Depth,
+    PIML_PRINT_RECORD_ROUTINE PrintRecordRoutine,
+    PIML_COMPARE_CONTENTS_ROUTINE CompareContentsRoutine
+    )
+{
+    PVOID pBufferToFree1;
+    PVOID pBufferToFree2;
+    PIML_GENERIC_RECORD *ppGeneric1;
+    PIML_GENERIC_RECORD *ppGeneric2;
+    PIML_GENERIC_RECORD pShow1;
+    PIML_GENERIC_RECORD pShow2;
+    BOOLEAN Result = FALSE;
+    PWSTR s1, s2;
+    int cmpResult;
+
+    ppGeneric1 = GetSortedGenericListAsArray( pIml1, pGeneric1 );
+    if (ppGeneric1 == NULL) {
+        return FALSE;
+        }
+    pBufferToFree1 = ppGeneric1;
+
+    ppGeneric2 = GetSortedGenericListAsArray( pIml2, pGeneric2 );
+    if (ppGeneric2 == NULL) {
+        HeapFree( GetProcessHeap(), 0, pBufferToFree1 );
+        return FALSE;
+        }
+    pBufferToFree2 = ppGeneric2;
+
+    pGeneric1 = *ppGeneric1++;
+    pGeneric2 = *ppGeneric2++;
+
+    while (TRUE) {
+        pShow1 = NULL;
+        pShow2 = NULL;
+        if (pGeneric1 == NULL) {
+            if (pGeneric2 == NULL) {
+                break;
+                }
+
+            //
+            // pGeneric2 is new
+            //
+
+            pShow2 = pGeneric2;
+            pGeneric2 = *ppGeneric2++;
+            Result = FALSE;
+            }
+        else
+        if (pGeneric2 == NULL) {
+            //
+            // pGeneric1 is new
+            //
+            pShow1 = pGeneric1;
+            pGeneric1 = *ppGeneric1++;
+            Result = FALSE;
+            }
+        else {
+            s1 = MP( PWSTR, pIml1, pGeneric1->Name );
+            s2 = MP( PWSTR, pIml2, pGeneric2->Name );
+
+            if (s1 == NULL) {
+                if (s2 == NULL) {
+                    cmpResult = 0;
+                    }
+                else {
+                    cmpResult = -1;
+                    }
+                }
+            else
+            if (s2 == NULL) {
+                cmpResult = 1;
+                }
+            else {
+                cmpResult = _wcsicmp( s1, s2 );
+                }
+            if (cmpResult == 0) {
+                if (Depth > 1) {
+                    Parents[ Depth - 1 ] = MP( PWSTR, pIml1, pGeneric1->Name );
+                    Result = CompareGenericIml( pIml1,
+                                                MP( PIML_GENERIC_RECORD, pIml1, pGeneric1->Records ),
+                                                pIml2,
+                                                MP( PIML_GENERIC_RECORD, pIml2, pGeneric2->Records ),
+                                                Parents,
+                                                Depth - 1,
+                                                PrintRecordRoutine,
+                                                CompareContentsRoutine
+                                              );
+                    }
+                else {
+                    Result = (*CompareContentsRoutine)( pIml1, pGeneric1,
+                                                        pIml2, pGeneric2,
+                                                        Parents
+                                                      );
+                    }
+
+                pGeneric1 = *ppGeneric1++;
+                pGeneric2 = *ppGeneric2++;
+                }
+            else
+            if (cmpResult > 0) {
+                pShow2 = pGeneric2;
+                pGeneric2 = *ppGeneric2++;
+                }
+            else {
+                pShow1 = pGeneric1;
+                pGeneric1 = *ppGeneric1++;
+                }
+            }
+
+        if (pShow1) {
+            (*PrintRecordRoutine)( pIml1, pShow1, Parents, Depth, 1 );
+            }
+
+        if (pShow2) {
+            (*PrintRecordRoutine)( pIml2, pShow2, Parents, Depth, 2 );
+            }
+        }
+
+    HeapFree( GetProcessHeap(), 0, pBufferToFree1 );
+    HeapFree( GetProcessHeap(), 0, pBufferToFree2 );
+    return Result;
+}
+
+
+char *FileActionStrings[] = {
+    "CreateNewFile",
+    "ModifyOldFile",
+    "DeleteOldFile",
+    "RenameOldFile",
+    "ModifyFileDateTime",
+    "ModifyFileAttributes"
+};
+
+
+PWSTR
+FormatFileTime(
+    LPFILETIME LastWriteTime
+    )
+{
+    FILETIME LocalFileTime;
+    SYSTEMTIME DateTime;
+    static WCHAR DateTimeBuffer[ 128 ];
+
+    FileTimeToLocalFileTime( LastWriteTime, &LocalFileTime );
+    FileTimeToSystemTime( &LocalFileTime, &DateTime );
+
+    _snwprintf( DateTimeBuffer,
+                128,
+                L"%02u/%02u/%04u %02u:%02u:%02u",
+                (ULONG)DateTime.wMonth,
+                (ULONG)DateTime.wDay,
+                (ULONG)DateTime.wYear,
+                (ULONG)DateTime.wHour,
+                (ULONG)DateTime.wMinute,
+                (ULONG)DateTime.wSecond
+              );
+
+    return DateTimeBuffer;
+}
+
+
+VOID
+PrintFileRecordIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PIML_GENERIC_RECORD pGeneric,
+    PWSTR Parents[],
+    ULONG Depth,
+    ULONG i
+    )
+{
+    PIML_FILE_RECORD pFile = (PIML_FILE_RECORD)pGeneric;
+
+    printf( "File: %ws\n    %u: %s\n",
+            MP( PWSTR, pIml, pFile->Name ),
+            i, FileActionStrings[ pFile->Action ]
+          );
+}
+
+BOOLEAN
+CompareFileContentsIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PIML_GENERIC_RECORD pGeneric1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2,
+    PIML_GENERIC_RECORD pGeneric2,
+    PWSTR Parents[]
+    )
+{
+    PIML_FILE_RECORD pFile1 = (PIML_FILE_RECORD)pGeneric1;
+    PIML_FILE_RECORD pFile2 = (PIML_FILE_RECORD)pGeneric2;
+    PIML_FILE_RECORD_CONTENTS pFileContents1;
+    PIML_FILE_RECORD_CONTENTS pFileContents2;
+    BOOLEAN ActionsDiffer = FALSE;
+    BOOLEAN DatesDiffer = FALSE;
+    BOOLEAN AttributesDiffer = FALSE;
+    BOOLEAN SizesDiffer = FALSE;
+    BOOLEAN ContentsDiffer = FALSE;
+    BOOLEAN Result = TRUE;
+    PCHAR s1, s2;
+    ULONG n;
+
+    pFileContents1 = MP( PIML_FILE_RECORD_CONTENTS, pIml1, pFile1->NewFile );
+    pFileContents2 = MP( PIML_FILE_RECORD_CONTENTS, pIml2, pFile2->NewFile );
+
+    if (pFile1->Action != pFile2->Action) {
+        ActionsDiffer = TRUE;
+        Result = FALSE;
+        }
+    else
+    if (pFileContents1 != NULL && pFileContents2 != NULL) {
+        if (pFile1->Action != CreateNewFile &&
+            ((pFileContents1->LastWriteTime.dwHighDateTime !=
+              pFileContents2->LastWriteTime.dwHighDateTime
+             ) ||
+             (pFileContents1->LastWriteTime.dwLowDateTime !=
+              pFileContents2->LastWriteTime.dwLowDateTime
+             )
+            )
+           ) {
+            DatesDiffer = TRUE;
+            Result = FALSE;
+            }
+
+        if (pFileContents1->FileAttributes != pFileContents2->FileAttributes) {
+            AttributesDiffer = TRUE;
+            Result = FALSE;
+            }
+
+        if (pFileContents1->FileSize != pFileContents2->FileSize) {
+            SizesDiffer = TRUE;
+            Result = FALSE;
+            }
+        else
+        if (pFileContents1->Contents == 0 ||
+            pFileContents2->Contents == 0 ||
+            memcmp( MP( PVOID, pIml1, pFileContents1->Contents ),
+                    MP( PVOID, pIml2, pFileContents2->Contents ),
+                    pFileContents1->FileSize
+                  ) != 0
+           ) {
+            s1 = MP( PVOID, pIml1, pFileContents1->Contents );
+            s2 = MP( PVOID, pIml2, pFileContents2->Contents );
+            if (s1 == NULL || s2 == NULL) {
+                n = 0;
+                }
+            else {
+                n = pFileContents1->FileSize;
+                }
+            while (n) {
+                if (*s1 != *s2) {
+                    n = pFileContents1->FileSize - n;
+                    break;
+                    }
+
+                n -= 1;
+                s1 += 1;
+                s2 += 1;
+                }
+
+            ContentsDiffer = TRUE;
+            Result = FALSE;
+            }
+        }
+
+    if (!Result) {
+        printf( "File: %ws\n", MP( PWSTR, pIml1, pFile1->Name ) );
+        if (ActionsDiffer) {
+            printf( "    1: Action - %s\n", FileActionStrings[ pFile1->Action ] );
+            printf( "    2: Action - %s\n", FileActionStrings[ pFile2->Action ] );
+            }
+        if (DatesDiffer) {
+            printf( "    1: LastWriteTime - %ws\n",
+                    FormatFileTime( &pFileContents1->LastWriteTime )
+                  );
+            printf( "    2: LastWriteTime - %ws\n",
+                    FormatFileTime( &pFileContents2->LastWriteTime )
+                  );
+            }
+        if (AttributesDiffer) {
+            printf( "    1: Attributes - 0x%08x\n", pFileContents1->FileAttributes );
+            printf( "    2: Attributes - 0x%08x\n", pFileContents2->FileAttributes );
+            }
+        if (SizesDiffer) {
+            printf( "    1: File Size - 0x%08x\n", pFileContents1->FileSize );
+            printf( "    2: File Size - 0x%08x\n", pFileContents2->FileSize );
+            }
+        if (ContentsDiffer) {
+            printf( "    1: Contents Differs\n" );
+            printf( "    2: from each other at offset %08x\n", n );
+            }
+        }
+
+    return Result;
+}
+
+
+char *KeyActionStrings[] = {
+    "CreateNewKey",
+    "DeleteOldKey",
+    "ModifyKeyValues"
+};
+
+char *ValueActionStrings[] = {
+    "CreateNewValue",
+    "DeleteOldValue",
+    "ModifyOldValue"
+};
+
+
+char *ValueTypeStrings[] = {
+    "REG_NONE",
+    "REG_SZ",
+    "REG_EXPAND_SZ",
+    "REG_BINARY",
+    "REG_DWORD",
+    "REG_DWORD_BIG_ENDIAN",
+    "REG_LINK",
+    "REG_MULTI_SZ",
+    "REG_RESOURCE_LIST",
+    "REG_FULL_RESOURCE_DESCRIPTOR",
+    "REG_RESOURCE_REQUIREMENTS_LIST"
+};
+
+VOID
+PrintKeyValueRecordIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PIML_GENERIC_RECORD pGeneric,
+    PWSTR Parents[],
+    ULONG Depth,
+    ULONG i
+    )
+{
+    PIML_KEY_RECORD pKey = (PIML_KEY_RECORD)pGeneric;
+    PIML_VALUE_RECORD pValue = (PIML_VALUE_RECORD)pGeneric;
+
+    if (Depth == 2) {
+        printf( "Key: %ws\n    %u: %s\n",
+                MP( PWSTR, pIml, pKey->Name ),
+                i, KeyActionStrings[ pKey->Action ]
+              );
+        }
+    else {
+        if (Parents[ 1 ] != NULL) {
+            printf( "Key: %ws\n", Parents[ 1 ] );
+            Parents[ 1 ] = NULL;
+            }
+
+        printf( "    Value: %ws\n        %u: %s\n",
+                MP( PWSTR, pIml, pValue->Name ),
+                i, ValueActionStrings[ pValue->Action ]
+              );
+        }
+}
+
+UCHAR BlanksForPadding[] =
+    "                                                                                  ";
+
+VOID
+PrintValueContents(
+    PCHAR PrefixString,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PIML_VALUE_RECORD_CONTENTS pValueContents
+    )
+{
+    ULONG ValueType;
+    ULONG ValueLength;
+    PVOID ValueData;
+    ULONG cbPrefix, cb, i, j;
+    PWSTR pw;
+    PULONG p;
+
+    ValueType = pValueContents->Type;
+    ValueLength = pValueContents->Length;
+    ValueData = MP( PVOID, pIml, pValueContents->Data );
+
+    cbPrefix = printf( "%s", PrefixString );
+    cb = cbPrefix + printf( "%s", ValueTypeStrings[ ValueType ] );
+
+    switch( ValueType ) {
+    case REG_SZ:
+    case REG_LINK:
+    case REG_EXPAND_SZ:
+        pw = (PWSTR)ValueData;
+        printf( " (%u) \"%.*ws\"\n", ValueLength, ValueLength/sizeof(WCHAR), pw );
+        break;
+
+    case REG_MULTI_SZ:
+        pw = (PWSTR)ValueData;
+        i  = 0;
+        if (*pw)
+        while (i < (ValueLength - 1) / sizeof( WCHAR )) {
+            if (i > 0) {
+                printf( " \\\n%.*s", cbPrefix, BlanksForPadding );
+                }
+            printf( "\"%ws\" ", pw+i );
+            do {
+                ++i;
+                }
+            while (pw[i] != UNICODE_NULL);
+
+            ++i;
+            }
+        printf( "\n" );
+        break;
+
+    case REG_DWORD:
+    case REG_DWORD_BIG_ENDIAN:
+        printf( " 0x%08x\n", *(PULONG)ValueData );
+        break;
+
+    case REG_RESOURCE_LIST:
+    case REG_FULL_RESOURCE_DESCRIPTOR:
+    case REG_RESOURCE_REQUIREMENTS_LIST:
+    case REG_BINARY:
+    case REG_NONE:
+        cb = printf( " [0x%08lx]", ValueLength );
+
+        if (ValueLength != 0) {
+            p = (PULONG)ValueData;
+            i = (ValueLength + 3) / sizeof( ULONG );
+            for (j=0; j<i; j++) {
+                if ((cbPrefix + cb + 11) > 78) {
+                    printf( " \\\n%.*s", cbPrefix, BlanksForPadding );
+                    cb = 0;
+                    }
+                else {
+                    cb += printf( " " );
+                    }
+
+                cb += printf( "0x%08lx", *p++ );
+                }
+            }
+
+        printf( "\n" );
+        break;
+    }
+}
+
+BOOLEAN
+CompareKeyValueContentsIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PIML_GENERIC_RECORD pGeneric1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2,
+    PIML_GENERIC_RECORD pGeneric2,
+    PWSTR Parents[]
+    )
+{
+    PIML_VALUE_RECORD pValue1 = (PIML_VALUE_RECORD)pGeneric1;
+    PIML_VALUE_RECORD pValue2 = (PIML_VALUE_RECORD)pGeneric2;
+    PIML_VALUE_RECORD_CONTENTS pValueContents1;
+    PIML_VALUE_RECORD_CONTENTS pValueContents2;
+    BOOLEAN ActionsDiffer = FALSE;
+    BOOLEAN TypesDiffer = FALSE;
+    BOOLEAN LengthsDiffer = FALSE;
+    BOOLEAN ContentsDiffer = FALSE;
+    BOOLEAN Result = TRUE;
+    PCHAR s1, s2;
+    ULONG n;
+
+    pValueContents1 = MP( PIML_VALUE_RECORD_CONTENTS, pIml1, pValue1->NewValue );
+    pValueContents2 = MP( PIML_VALUE_RECORD_CONTENTS, pIml2, pValue2->NewValue );
+
+    if (pValue1->Action != pValue2->Action) {
+        ActionsDiffer = TRUE;
+        Result = FALSE;
+        }
+    else
+    if (pValueContents1 != NULL && pValueContents2 != NULL) {
+        if (pValue1->Action != CreateNewValue &&
+            (pValueContents1->Type != pValueContents2->Type)
+           ) {
+            TypesDiffer = TRUE;
+            Result = FALSE;
+            }
+
+        if (pValueContents1->Length != pValueContents2->Length) {
+            LengthsDiffer = TRUE;
+            Result = FALSE;
+            }
+        else
+        if (pValueContents1->Data == 0 ||
+            pValueContents2->Data == 0 ||
+            memcmp( MP( PVOID, pIml1, pValueContents1->Data ),
+                    MP( PVOID, pIml2, pValueContents2->Data ),
+                    pValueContents1->Length
+                  ) != 0
+           ) {
+            s1 = MP( PVOID, pIml1, pValueContents1->Data );
+            s2 = MP( PVOID, pIml2, pValueContents2->Data );
+            if (s1 == NULL || s2 == NULL) {
+                n = 0;
+                }
+            else {
+                n = pValueContents1->Length;
+                }
+            while (n) {
+                if (*s1 != *s2) {
+                    n = pValueContents1->Length - n;
+                    break;
+                    }
+
+                n -= 1;
+                s1 += 1;
+                s2 += 1;
+                }
+
+            ContentsDiffer = TRUE;
+            Result = FALSE;
+            }
+        }
+
+    if (!Result) {
+        if (Parents[ 2 ] != NULL) {
+            printf( "Key: %ws\n", Parents[ 2 ] );
+            Parents[ 2 ] = NULL;
+            }
+
+        printf( "    Value: %ws\n", MP( PWSTR, pIml1, pValue1->Name ) );
+        if (ActionsDiffer) {
+            printf( "        1: Action - %s\n", ValueActionStrings[ pValue1->Action ] );
+            printf( "        2: Action - %s\n", ValueActionStrings[ pValue2->Action ] );
+            }
+        if (TypesDiffer || LengthsDiffer || ContentsDiffer ) {
+            PrintValueContents( "        1: ", pIml1, pValueContents1 );
+            PrintValueContents( "        2: ", pIml2, pValueContents2 );
+            }
+        }
+
+    return Result;
+}
+
+
+char *IniActionStrings[] = {
+    "CreateNewIniFile",
+    "ModifyOldIniFile"
+};
+
+char *SectionActionStrings[] = {
+    "CreateNewSection",
+    "DeleteOldSection",
+    "ModifySectionVariables"
+};
+
+char *VariableActionStrings[] = {
+    "CreateNewVariable",
+    "DeleteOldVariable",
+    "ModifyOldVariable"
+};
+
+VOID
+PrintIniSectionVariableRecordIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PIML_GENERIC_RECORD pGeneric,
+    PWSTR Parents[],
+    ULONG Depth,
+    ULONG i
+    )
+{
+    PIML_INI_RECORD pIni = (PIML_INI_RECORD)pGeneric;
+    PIML_INISECTION_RECORD pSection = (PIML_INISECTION_RECORD)pGeneric;
+    PIML_INIVARIABLE_RECORD pVariable = (PIML_INIVARIABLE_RECORD)pGeneric;
+
+    if (Depth == 3) {
+        printf( "Ini File: %ws\n    %u: %s\n",
+                MP( PWSTR, pIml, pIni->Name ),
+                i, IniActionStrings[ pIni->Action ]
+              );
+        }
+    else
+    if (Depth == 2) {
+        if (Parents[ 2 ] != NULL) {
+            printf( "Ini File: %ws\n", Parents[ 2 ] );
+            Parents[ 2 ] = NULL;
+            }
+
+        printf( "    Section: %ws\n    %u: %s\n",
+                MP( PWSTR, pIml, pSection->Name ),
+                i, SectionActionStrings[ pSection->Action ]
+              );
+        }
+    else {
+        if (Parents[ 2 ] != NULL) {
+            printf( "Ini File: %ws\n", Parents[ 2 ] );
+            Parents[ 2 ] = NULL;
+            }
+
+        if (Parents[ 1 ] != NULL) {
+            printf( "    Section: %ws\n", Parents[ 1 ] );
+            Parents[ 1 ] = NULL;
+            }
+
+        printf( "        Variable: %ws\n            %u: %s\n",
+                MP( PWSTR, pIml, pVariable->Name ),
+                i, VariableActionStrings[ pVariable->Action ]
+              );
+        }
+}
+
+BOOLEAN
+CompareIniSectionVariableContentsIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PIML_GENERIC_RECORD pGeneric1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2,
+    PIML_GENERIC_RECORD pGeneric2,
+    PWSTR Parents[]
+    )
+{
+    PIML_INIVARIABLE_RECORD pVariable1 = (PIML_INIVARIABLE_RECORD)pGeneric1;
+    PIML_INIVARIABLE_RECORD pVariable2 = (PIML_INIVARIABLE_RECORD)pGeneric2;
+    PWSTR  pVariableContents1;
+    PWSTR  pVariableContents2;
+    BOOLEAN ActionsDiffer = FALSE;
+    BOOLEAN ContentsDiffer = FALSE;
+    BOOLEAN Result = TRUE;
+
+    pVariableContents1 = MP( PWSTR, pIml1, pVariable1->NewValue );
+    pVariableContents2 = MP( PWSTR, pIml2, pVariable2->NewValue );
+
+    if (pVariable1->Action != pVariable2->Action) {
+        ActionsDiffer = TRUE;
+        Result = FALSE;
+        }
+    else
+    if (pVariableContents1 != NULL && pVariableContents2 != NULL) {
+        if (wcscmp( pVariableContents1, pVariableContents2 ) != 0) {
+            ContentsDiffer = TRUE;
+            Result = FALSE;
+            }
+        }
+
+    if (!Result) {
+        if (Parents[ 2 ] != NULL) {
+            printf( "Ini File: %ws\n", Parents[ 2 ] );
+            Parents[ 2 ] = NULL;
+            }
+
+        if (Parents[ 1 ] != NULL) {
+            printf( "    Section: %ws\n", Parents[ 1 ] );
+            Parents[ 1 ] = NULL;
+            }
+
+        printf( "        Variable: %ws\n", MP( PWSTR, pIml1, pVariable1->Name ) );
+        if (ActionsDiffer) {
+            printf( "            1: Action - %s\n", VariableActionStrings[ pVariable1->Action ] );
+            printf( "            2: Action - %s\n", VariableActionStrings[ pVariable2->Action ] );
+            }
+        if (ContentsDiffer) {
+            printf( "            1: '%ws'\n", pVariableContents1 );
+            printf( "            2: '%ws'\n", pVariableContents2 );
+            }
+        }
+
+    return Result;
+}
+
+
+
+
+BOOLEAN
+CompareIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml1,
+    PINSTALLATION_MODIFICATION_LOGFILE pIml2
+    )
+{
+    BOOLEAN Result = TRUE;
+    PWSTR Parents[ 3 ];
+
+    Result &= CompareGenericIml( pIml1, MP( PIML_GENERIC_RECORD, pIml1, pIml1->FileRecords ),
+                                 pIml2, MP( PIML_GENERIC_RECORD, pIml2, pIml2->FileRecords ),
+                                 NULL,
+                                 1,
+                                 PrintFileRecordIml,
+                                 CompareFileContentsIml
+                               );
+
+    memset( Parents, 0, sizeof( Parents ) );
+    Result &= CompareGenericIml( pIml1, MP( PIML_GENERIC_RECORD, pIml1, pIml1->KeyRecords ),
+                                 pIml2, MP( PIML_GENERIC_RECORD, pIml2, pIml2->KeyRecords ),
+                                 Parents,
+                                 2,
+                                 PrintKeyValueRecordIml,
+                                 CompareKeyValueContentsIml
+                               );
+
+    memset( Parents, 0, sizeof( Parents ) );
+    Result &= CompareGenericIml( pIml1, MP( PIML_GENERIC_RECORD, pIml1, pIml1->IniRecords ),
+                                 pIml2, MP( PIML_GENERIC_RECORD, pIml2, pIml2->IniRecords ),
+                                 Parents,
+                                 3,
+                                 PrintIniSectionVariableRecordIml,
+                                 CompareIniSectionVariableContentsIml
+                               );
+
+    return Result;
+}
diff --git a/private/sdktools/instaler/compinst.rc b/private/sdktools/instaler/compinst.rc
new file mode 100644
index 000000000..a5f44b528
--- /dev/null
+++ b/private/sdktools/instaler/compinst.rc
@@ -0,0 +1,12 @@
+#include "instaler.h"
+#include <ntverp.h>
+
+#define	VER_FILETYPE	VFT_APP
+#define	VER_FILESUBTYPE	VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "Windows NT Instaler Compare Program"
+#define VER_INTERNALNAME_STR        "COMPINST\0"
+#define VER_ORIGINALFILENAME_STR    "COMPINST.EXE"
+
+#include "common.ver"
+
+RCINCLUDE errormsg.rc
diff --git a/private/sdktools/instaler/debug.c b/private/sdktools/instaler/debug.c
new file mode 100644
index 000000000..c20b9eed4
--- /dev/null
+++ b/private/sdktools/instaler/debug.c
@@ -0,0 +1,481 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    debug.c
+
+Abstract:
+
+    Main loop for INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+DWORD
+DebugEventHandler(
+    LPDEBUG_EVENT DebugEvent
+    );
+
+VOID
+InstallBreakpointsForDLL(
+    PPROCESS_INFO Process,
+    LPVOID BaseOfDll
+    );
+
+VOID
+RemoveBreakpointsForDLL(
+    PPROCESS_INFO Process,
+    LPVOID BaseOfDll
+    );
+
+char *DebugEventNames[] = {
+    "Unknown debug event",
+    "EXCEPTION_DEBUG_EVENT",
+    "CREATE_THREAD_DEBUG_EVENT",
+    "CREATE_PROCESS_DEBUG_EVENT",
+    "EXIT_THREAD_DEBUG_EVENT",
+    "EXIT_PROCESS_DEBUG_EVENT",
+    "LOAD_DLL_DEBUG_EVENT",
+    "UNLOAD_DLL_DEBUG_EVENT",
+    "OUTPUT_DEBUG_STRING_EVENT",
+    "RIP_EVENT",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    "Unknown debug event",
+    NULL
+};
+
+
+VOID
+DebugEventLoop( VOID )
+{
+    DEBUG_EVENT DebugEvent;
+    DWORD ContinueStatus;
+    DWORD OldPriority;
+
+    //
+    // We want to process debug events quickly
+    //
+
+    OldPriority = GetPriorityClass( GetCurrentProcess() );
+    SetPriorityClass( GetCurrentProcess(), HIGH_PRIORITY_CLASS );
+
+    do {
+        if (!WaitForDebugEvent( &DebugEvent, INFINITE )) {
+            DeclareError( INSTALER_WAITDEBUGEVENT_FAILED, GetLastError() );
+            ExitProcess( 1 );
+            }
+
+        if (DebugEvent.dwDebugEventCode == EXCEPTION_DEBUG_EVENT) {
+            if (DebugEvent.u.Exception.ExceptionRecord.ExceptionCode != STATUS_BREAKPOINT &&
+                DebugEvent.u.Exception.ExceptionRecord.ExceptionCode != STATUS_SINGLE_STEP
+               ) {
+                DbgEvent( DBGEVENT, ( "Debug exception event - Code: %x  Address: %x  Info: [%u] %x %x %x %x\n",
+                                      DebugEvent.u.Exception.ExceptionRecord.ExceptionCode,
+                                      DebugEvent.u.Exception.ExceptionRecord.ExceptionAddress,
+                                      DebugEvent.u.Exception.ExceptionRecord.NumberParameters,
+                                      DebugEvent.u.Exception.ExceptionRecord.ExceptionInformation[ 0 ],
+                                      DebugEvent.u.Exception.ExceptionRecord.ExceptionInformation[ 1 ],
+                                      DebugEvent.u.Exception.ExceptionRecord.ExceptionInformation[ 2 ],
+                                      DebugEvent.u.Exception.ExceptionRecord.ExceptionInformation[ 3 ]
+                                    )
+                        );
+                }
+            }
+        else {
+            DbgEvent( DBGEVENT, ( "Debug %s (%x) event\n",
+                                  DebugEventNames[ DebugEvent.dwDebugEventCode ],
+                                  DebugEvent.dwDebugEventCode
+                                )
+                    );
+            }
+        ContinueStatus = DebugEventHandler( &DebugEvent );
+        if (!ContinueDebugEvent( DebugEvent.dwProcessId,
+                                 DebugEvent.dwThreadId,
+                                 ContinueStatus
+                               )
+           ) {
+            DeclareError( INSTALER_CONTDEBUGEVENT_FAILED, GetLastError() );
+            ExitProcess( 1 );
+            }
+        }
+    while (!IsListEmpty( &ProcessListHead ));
+
+
+    //
+    // Drop back to old priority to interact with user.
+    //
+
+    SetPriorityClass( GetCurrentProcess(), OldPriority );
+}
+
+
+DWORD
+DebugEventHandler(
+    LPDEBUG_EVENT DebugEvent
+    )
+{
+    DWORD ContinueStatus;
+    PPROCESS_INFO Process;
+    PTHREAD_INFO Thread;
+    PBREAKPOINT_INFO Breakpoint;
+
+    ContinueStatus = (DWORD)DBG_CONTINUE;
+    if (FindProcessAndThreadForEvent( DebugEvent, &Process, &Thread )) {
+        switch (DebugEvent->dwDebugEventCode) {
+            case CREATE_PROCESS_DEBUG_EVENT:
+                //
+                // Create process event includes first thread of process
+                // as well.  Remember process and thread in our process tree
+                //
+
+                if (AddProcess( DebugEvent, &Process )) {
+                    InheritHandles( Process );
+                    AddThread( DebugEvent, Process, &Thread );
+                    }
+                break;
+
+            case EXIT_PROCESS_DEBUG_EVENT:
+                //
+                // Exit process event includes last thread of process
+                // as well.  Remove process and thread from our process tree
+                //
+
+                if (DeleteThread( Process, Thread )) {
+                    DeleteProcess( Process );
+                    }
+                break;
+
+            case CREATE_THREAD_DEBUG_EVENT:
+                //
+                // Create thread.  Remember thread in our process tree.
+                //
+
+                AddThread( DebugEvent, Process, &Thread );
+                break;
+
+            case EXIT_THREAD_DEBUG_EVENT:
+                //
+                // Exit thread.  Remove thread from our process tree.
+                //
+
+                DeleteThread( Process, Thread );
+                break;
+
+            case LOAD_DLL_DEBUG_EVENT:
+                //
+                // DLL just mapped into process address space.  See if it is one
+                // of the ones we care about and if so, install the necessary
+                // breakpoints.
+                //
+
+                InstallBreakpointsForDLL( Process, DebugEvent->u.LoadDll.lpBaseOfDll );
+                break;
+
+            case UNLOAD_DLL_DEBUG_EVENT:
+                //
+                // DLL just unmapped from process address space.  See if it is one
+                // of the ones we care about and if so, remove the breakpoints we
+                // installed when it was mapped.
+                //
+
+                RemoveBreakpointsForDLL( Process, DebugEvent->u.UnloadDll.lpBaseOfDll );
+                break;
+
+            case OUTPUT_DEBUG_STRING_EVENT:
+            case RIP_EVENT:
+                //
+                // Ignore these
+                //
+                break;
+
+            case EXCEPTION_DEBUG_EVENT:
+                //
+                // Assume we wont handle this exception
+                //
+
+                ContinueStatus = (DWORD)DBG_EXCEPTION_NOT_HANDLED;
+                switch (DebugEvent->u.Exception.ExceptionRecord.ExceptionCode) {
+                    //
+                    // Breakpoint exception.
+                    //
+
+                    case STATUS_BREAKPOINT:
+                        EnterCriticalSection( &BreakTable );
+                        if (Thread->BreakpointToStepOver != NULL) {
+                            //
+                            // If this breakpoint was in place to step over an API entry
+                            // point breakpoint, then deal with it by ending single
+                            // step mode, resuming all threads in the process and
+                            // reinstalling the API breakpoint we just stepped over.
+                            // Finally return handled for this exception so the
+                            // thread can proceed.
+                            //
+
+                            EndSingleStepBreakpoint( Process, Thread );
+                            HandleThreadsForSingleStep( Process, Thread, FALSE );
+                            InstallBreakpoint( Process, Thread->BreakpointToStepOver );
+                            Thread->BreakpointToStepOver = NULL;
+                            ContinueStatus = (DWORD)DBG_EXCEPTION_HANDLED;
+                            }
+                        else {
+                            //
+                            // Otherwise, see if this breakpoint is either an API entry
+                            // point breakpoint for the process or a return address
+                            // breakpoint for a thread in the process.
+                            //
+                            Breakpoint = FindBreakpoint( DebugEvent->u.Exception.ExceptionRecord.ExceptionAddress,
+                                                         Process,
+                                                         Thread
+                                                       );
+                            if (Breakpoint != NULL) {
+                                //
+                                // This is one of our breakpoints, call the breakpoint
+                                // handler.
+                                //
+                                if (HandleBreakpoint( Process, Thread, Breakpoint )) {
+                                    //
+                                    // Now single step over this breakpoint, by removing it and
+                                    // setting a breakpoint at the next instruction (or using
+                                    // single stepmode if the processor supports it).  We also
+                                    // suspend all the threads in the process except this one so
+                                    // we know the next breakpoint/single step exception we see
+                                    // for this process will be for this one.
+                                    //
+
+                                    Thread->BreakpointToStepOver = Breakpoint;
+                                    RemoveBreakpoint( Process, Breakpoint );
+                                    HandleThreadsForSingleStep( Process, Thread, TRUE );
+                                    BeginSingleStepBreakpoint( Process, Thread );
+                                    }
+                                else {
+                                    Thread->BreakpointToStepOver = NULL;
+                                    }
+
+                                ContinueStatus = (DWORD)DBG_EXCEPTION_HANDLED;
+                                }
+                            else {
+                                DbgEvent( DBGEVENT, ( "Skipping over hardcoded breakpoint at %x\n",
+                                                      DebugEvent->u.Exception.ExceptionRecord.ExceptionAddress
+                                                    )
+                                        );
+
+                                //
+                                // If not one of our breakpoints, assume it is a hardcoded
+                                // breakpoint and skip over it.  This will get by the one
+                                // breakpoint in LdrInit triggered by the process being
+                                // invoked with DEBUG_PROCESS.
+                                //
+
+                                if (SkipOverHardcodedBreakpoint( Process,
+                                                                 Thread,
+                                                                 DebugEvent->u.Exception.ExceptionRecord.ExceptionAddress
+                                                               )
+                                   ) {
+                                    //
+                                    // If we successfully skipped over this hard-coded breakpoint
+                                    // then return handled for this exception.
+                                    //
+
+                                    ContinueStatus = (DWORD)DBG_EXCEPTION_HANDLED;
+                                    }
+                                }
+                            }
+                        LeaveCriticalSection( &BreakTable );
+                        break;
+
+                    case STATUS_SINGLE_STEP:
+                        //
+                        // We should only see this exception on processors that
+                        // support a single step mode.
+                        //
+
+                        EnterCriticalSection( &BreakTable );
+                        if (Thread->BreakpointToStepOver != NULL) {
+                            EndSingleStepBreakpoint( Process, Thread );
+                            HandleThreadsForSingleStep( Process, Thread, FALSE );
+                            InstallBreakpoint( Process, Thread->BreakpointToStepOver );
+                            Thread->BreakpointToStepOver = NULL;
+                            ContinueStatus = (DWORD)DBG_EXCEPTION_HANDLED;
+                            }
+                        LeaveCriticalSection( &BreakTable );
+                        break;
+
+                    case STATUS_VDM_EVENT:
+                        //
+                        // Returning NOT_HANDLED will cause the default behavior to
+                        // occur.
+                        //
+                        break;
+
+                    default:
+                        DbgEvent( DBGEVENT, ( "Unknown exception: %08x at %08x\n",
+                                              DebugEvent->u.Exception.ExceptionRecord.ExceptionCode,
+                                              DebugEvent->u.Exception.ExceptionRecord.ExceptionAddress
+                                            )
+                                );
+                        break;
+                    }
+                break;
+
+            default:
+                DbgEvent( DBGEVENT, ( "Unknown debug event\n" ) );
+                break;
+            }
+        }
+    return( ContinueStatus );
+}
+
+
+VOID
+InstallBreakpointsForDLL(
+    PPROCESS_INFO Process,
+    LPVOID BaseOfDll
+    )
+{
+    UCHAR ModuleIndex, ApiIndex;
+    PBREAKPOINT_INFO Breakpoint;
+
+    //
+    // Loop over module table to see if the base address of this DLL matches
+    // one of the module handles we want to set breakpoints in.  If not, ignore
+    // event.
+    //
+
+    for (ModuleIndex=0; ModuleIndex<MAXIMUM_MODULE_INDEX; ModuleIndex++) {
+        if (ModuleInfo[ ModuleIndex ].ModuleHandle == BaseOfDll) {
+            //
+            // Loop over the list of API entry points for this module and set
+            // a process specific breakpoint at the first instruction of each
+            // entrypoint.
+            //
+
+            for (ApiIndex=0; ApiIndex<MAXIMUM_API_INDEX; ApiIndex++) {
+                if (ModuleIndex == ApiInfo[ ApiIndex ].ModuleIndex) {
+                    if (CreateBreakpoint( ApiInfo[ ApiIndex ].EntryPointAddress,
+                                          Process,
+                                          NULL,    // process specific
+                                          ApiIndex,
+                                          NULL,
+                                          &Breakpoint
+                                        )
+                       ) {
+                        Breakpoint->ModuleName = ModuleInfo[ ApiInfo[ ApiIndex ].ModuleIndex ].ModuleName;
+                        Breakpoint->ProcedureName = ApiInfo[ ApiIndex ].EntryPointName;
+                        DbgEvent( DBGEVENT, ( "Installed breakpoint for %ws!%s at %08x\n",
+                                               Breakpoint->ModuleName,
+                                               Breakpoint->ProcedureName,
+                                               ApiInfo[ ApiIndex ].EntryPointAddress
+                                            )
+                                );
+                        }
+                    }
+                }
+            break;
+            }
+        }
+}
+
+VOID
+RemoveBreakpointsForDLL(
+    PPROCESS_INFO Process,
+    LPVOID BaseOfDll
+    )
+{
+    UCHAR ModuleIndex, ApiIndex;
+
+    //
+    // Loop over module index to see if the base address of this DLL matches
+    // one of the module handles we set breakpoints in above.  If not, ignore
+    // event.
+    //
+
+    for (ModuleIndex=0; ModuleIndex<MAXIMUM_MODULE_INDEX; ModuleIndex++) {
+        if (ModuleInfo[ ModuleIndex ].ModuleHandle == BaseOfDll) {
+            //
+            // Loop over the list of API entry points for this module and remove
+            // each process specific breakpoint set above for each entrypoint.
+            //
+
+            for (ApiIndex=0; ApiIndex<MAXIMUM_API_INDEX; ApiIndex++) {
+                if (ModuleIndex == ApiInfo[ ApiIndex ].ModuleIndex) {
+                    DestroyBreakpoint( ApiInfo[ ApiIndex ].EntryPointAddress,
+                                       Process,
+                                       NULL     // process specific
+                                     );
+                    }
+                }
+            break;
+            }
+        }
+}
+
+
+BOOLEAN
+InstallBreakpoint(
+    PPROCESS_INFO Process,
+    PBREAKPOINT_INFO Breakpoint
+    )
+{
+    if (!Breakpoint->SavedInstructionValid &&
+        !ReadMemory( Process,
+                     Breakpoint->Address,
+                     &Breakpoint->SavedInstruction,
+                     SizeofBreakpointInstruction,
+                     "save instruction"
+                    )
+       ) {
+        return FALSE;
+        }
+    else
+    if (!WriteMemory( Process,
+                      Breakpoint->Address,
+                      BreakpointInstruction,
+                      SizeofBreakpointInstruction,
+                      "breakpoint instruction"
+                    )
+       ) {
+        return FALSE;
+        }
+    else {
+        Breakpoint->SavedInstructionValid = TRUE;
+        return TRUE;
+        }
+}
+
+BOOLEAN
+RemoveBreakpoint(
+    PPROCESS_INFO Process,
+    PBREAKPOINT_INFO Breakpoint
+    )
+{
+    if (!Breakpoint->SavedInstructionValid ||
+        !WriteMemory( Process,
+                      Breakpoint->Address,
+                      &Breakpoint->SavedInstruction,
+                      SizeofBreakpointInstruction,
+                      "restore saved instruction"
+                    )
+       ) {
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
diff --git a/private/sdktools/instaler/dir.bmp b/private/sdktools/instaler/dir.bmp
new file mode 100644
index 000000000..d8794617d
--- /dev/null
+++ b/private/sdktools/instaler/dir.bmp
diff --git a/private/sdktools/instaler/error.c b/private/sdktools/instaler/error.c
new file mode 100644
index 000000000..2241d8642
--- /dev/null
+++ b/private/sdktools/instaler/error.c
@@ -0,0 +1,202 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    error.c
+
+Abstract:
+
+    Error handle module for the INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+VOID
+TraceDisplay(
+    const char *FormatString,
+    ...
+    )
+{
+    va_list arglist;
+
+    va_start( arglist, FormatString );
+    vprintf( FormatString, arglist );
+    if (InstalerLogFile) {
+        vfprintf( InstalerLogFile, FormatString, arglist );
+        }
+    va_end( arglist );
+    fflush( stdout );
+    return;
+}
+
+VOID
+CDECL
+DeclareError(
+    UINT ErrorCode,
+    UINT SupplementalErrorCode,
+    ...
+    )
+{
+    va_list arglist;
+    HMODULE ModuleHandle;
+    DWORD Flags, Size;
+    WCHAR MessageBuffer[ 512 ];
+
+    va_start( arglist, SupplementalErrorCode );
+
+    if ((ErrorCode & 0x0FFF0000) >> 16 == FACILITY_APPLICATION) {
+        ModuleHandle = InstalerModuleHandle;
+        Flags = FORMAT_MESSAGE_FROM_HMODULE;
+        }
+    else
+    if ((ErrorCode & 0x0FFF0000) == FACILITY_NT) {
+        ErrorCode ^= FACILITY_NT;
+        ModuleHandle = ModuleInfo[ NTDLL_MODULE_INDEX ].ModuleHandle;
+        Flags = FORMAT_MESSAGE_FROM_HMODULE;
+        }
+    else {
+        ModuleHandle = NULL;
+        Flags = FORMAT_MESSAGE_FROM_SYSTEM;
+        }
+
+    Size = FormatMessage( Flags,
+                          (LPCVOID)ModuleHandle,
+                          ErrorCode,
+                          0,
+                          MessageBuffer,
+                          sizeof( MessageBuffer ) / sizeof( WCHAR ),
+                          &arglist
+                        );
+    va_end( arglist );
+
+    if (Size != 0) {
+        printf( "INSTALER: %ws", MessageBuffer );
+        }
+    else {
+        printf( "INSTALER: Unable to get message text for %08x\n", ErrorCode );
+        }
+
+    if (ModuleHandle == InstalerModuleHandle &&
+        SupplementalErrorCode != 0 &&
+        SupplementalErrorCode != ERROR_GEN_FAILURE &&
+        SupplementalErrorCode != STATUS_UNSUCCESSFUL
+       ) {
+        if ((SupplementalErrorCode & 0x0FFF0000) == FACILITY_NT) {
+            SupplementalErrorCode ^= FACILITY_NT;
+            ModuleHandle = ModuleInfo[ NTDLL_MODULE_INDEX ].ModuleHandle;
+            Flags = FORMAT_MESSAGE_FROM_HMODULE;
+            }
+        else {
+            ModuleHandle = NULL;
+            Flags = FORMAT_MESSAGE_FROM_SYSTEM;
+            }
+        Size = FormatMessage( Flags,
+                              (LPCVOID)ModuleHandle,
+                              SupplementalErrorCode,
+                              0,
+                              MessageBuffer,
+                              sizeof( MessageBuffer ) / sizeof( WCHAR ),
+                              NULL
+                            );
+        if (Size != 0) {
+            while (Size != 0 && MessageBuffer[ Size ] <= L' ') {
+                MessageBuffer[ Size ] = UNICODE_NULL;
+                Size -= 1;
+                }
+
+            printf( "          '%ws'\n", MessageBuffer );
+            }
+        else {
+            printf( "INSTALER: Unable to get message text for %08x\n", SupplementalErrorCode );
+            }
+        }
+
+
+
+    return;
+}
+
+WCHAR MessageBoxTitle[ MAX_PATH ];
+
+
+UINT
+CDECL
+AskUser(
+    UINT MessageBoxFlags,
+    UINT MessageId,
+    UINT NumberOfArguments,
+    ...
+    )
+{
+    va_list arglist;
+    HMODULE ModuleHandle;
+    DWORD Flags, Size;
+    WCHAR MessageBuffer[ 512 ];
+    PWSTR s;
+    ULONG Args[ 24 ];
+    PULONG p;
+
+    if (MessageBoxTitle[ 0 ] == UNICODE_NULL) {
+        Args[ 0 ] = (ULONG)InstallationName;
+        Args[ 1 ] = 0;
+        Size = FormatMessageW( FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+                               (LPCVOID)InstalerModuleHandle,
+                               INSTALER_ASKUSER_TITLE,
+                               0,
+                               MessageBoxTitle,
+                               sizeof( MessageBoxTitle ) / sizeof( WCHAR ),
+                               (va_list *)Args
+                             );
+        if (Size == 0) {
+            _snwprintf( MessageBoxTitle,
+                        sizeof( MessageBoxTitle ) / sizeof( WCHAR ),
+                        L"Application Installation Monitor Program - %ws",
+                        InstallationName
+                      );
+            }
+        else {
+            if ((s = wcschr( MessageBoxTitle, L'\r' )) ||
+                (s = wcschr( MessageBoxTitle, L'\n' ))
+               ) {
+                *s = UNICODE_NULL;
+                }
+            }
+        }
+
+    va_start( arglist, NumberOfArguments );
+    p = Args;
+    while (NumberOfArguments--) {
+        *p++ = va_arg( arglist, ULONG );
+        }
+    *p++ = 0;
+    va_end( arglist );
+
+    Size = FormatMessageW( FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+                           (LPCVOID)InstalerModuleHandle,
+                           MessageId,
+                           0,
+                           MessageBuffer,
+                           sizeof( MessageBuffer ) / sizeof( WCHAR ),
+                           (va_list *)Args
+                         );
+
+    if (Size != 0) {
+        return MessageBox( NULL,
+                           MessageBuffer,
+                           MessageBoxTitle,
+                           MB_SETFOREGROUND | MessageBoxFlags
+                         );
+        }
+    else {
+        return IDOK;
+        }
+}
diff --git a/private/sdktools/instaler/errormsg.mc b/private/sdktools/instaler/errormsg.mc
new file mode 100644
index 000000000..4c91402ef
--- /dev/null
+++ b/private/sdktools/instaler/errormsg.mc
@@ -0,0 +1,219 @@
+;/*++ BUILD Version: 0001    // Increment this if a change has global effects
+;
+;Copyright (c) 1991-1992  Microsoft Corporation
+;
+;Module Name:
+;
+;    errormsg.h
+;
+;Abstract:
+;
+;    This file contains the error code definitions and message for the
+;    INSTALER program.
+;
+;Author:
+;
+;    Steve Wood (stevewo) 09-Aug-1994
+;
+;--*/
+;
+;#ifndef _INSTALER_ERRORMSG_
+;#define _INSTALER_ERRORMSG_
+;
+;
+
+SeverityNames=(Success=0x0:APP_SEVERITY_SUCCESS
+               Informational=0x1:APP_SEVERITY_INFORMATIONAL
+               Warning=0x2:APP_SEVERITY_WARNING
+               Error=0x3:APP_SEVERITY_ERROR
+              )
+
+FacilityNames=(Application=0x100:FACILITY_APPLICATION)
+
+;#define FACILITY_NT 0x0FFF0000
+
+MessageId=0001 Severity=Error Facility=Application SymbolicName=INSTALER_MISSING_MODULE
+Language=English
+Unable to find %1 dynamic link library.
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_MISSING_ENTRYPOINT
+Language=English
+Unable to find %1 entry point in %2 dynamic link library.
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_CANT_DEBUG_PROGRAM
+Language=English
+Unable to debug '%1'
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_WAITDEBUGEVENT_FAILED
+Language=English
+Unable to wait for debug event.
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_CONTDEBUGEVENT_FAILED
+Language=English
+Unable to continue debug event.
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_DUPLICATE_PROCESS_ID
+Language=English
+Duplicate Process Id (%1!x!).
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_MISSING_PROCESS_ID
+Language=English
+Missing Process Id (%1!x!).
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_DUPLICATE_THREAD_ID
+Language=English
+Duplicate Thread Id (%1!x!) for Process Id (%2!x!)
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_MISSING_THREAD_ID
+Language=English
+Missing Thread Id (%1!x!) for Process Id (%2!x!)
+.
+
+MessageId= Severity=Error Facility=Application SymbolicName=INSTALER_CANT_ACCESS_FILE
+Language=English
+Unable to access file (%1!ws!) for comparison.  Assuming different.
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_ASKUSER_TITLE
+Language=English
+Application Installation Monitor - %1!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_ASKUSER_ROOTSCAN
+Language=English
+The application installation program is about to scan root directory of %1!ws!
+Press cancel if you don't want the program to do that.
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_ASKUSER_GETVERSION
+Language=English
+The application installation program is about to ask for the version of
+the operating system.  Press OK if you want to tell the truth.  Press
+cancel if you want to lie to the program and tell it that it is running
+on Windows 95
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_ASKUSER_REGCONNECT
+Language=English
+The application installation program is about to connect to the registry of a
+remote machine (%1!ws!)  The INSTALER program is unable to track changes made to
+a remote registry.  Press OK if you want to proceed anyway.  Press cancel if you
+want to fail the program's attempt to connect to the registry of the remote machine.
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_SET_DIRECTORY
+Language=English
+%2!05u! Current Directory now: %1!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_INI_CREATE
+Language=English
+%5!05u! Created: %1!ws! [%2!ws!] %3!ws! = '%4!ws!'
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_INI_DELETE
+Language=English
+%5!05u! Deleted: %1!ws! [%2!ws!] %3!ws! = '%4!ws!'
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_INI_CHANGE
+Language=English
+%6!05u! Changed: %1!ws! [%2!ws!] %3!ws! = '%4!ws!' (was '%5!ws!')
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_INI_DELETE_SECTION
+Language=English
+%3!05u! Deleted: %1!ws! [%2!ws!]
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_SCAN_DIRECTORY
+Language=English
+%4!05u! Scanned %3!u! entries from directory: %1!ws!\%2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_CREATE_FILE
+Language=English
+%3!05u! Created %1!ws!: %2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_WRITE_FILE
+Language=English
+%3!05u! Writing %1!ws!: %2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_READ_FILE
+Language=English
+%3!05u! Reading %1!ws!: %2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_DELETE_FILE
+Language=English
+%3!05u! Deleted %1!ws!: %2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_DELETE_TEMP_FILE
+Language=English
+%3!05u! Deleted %1!ws!: %2!ws! (temporary)
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_RENAME_FILE
+Language=English
+%4!05u! Renamed %1!ws!: %2!ws!
+                to: %3!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_RENAME_TEMP_FILE
+Language=English
+%4!05u! Renamed %1!ws!: %2!ws! (temporary)
+                to: %3!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_WRITE_KEY
+Language=English
+%2!05u! Opened key for write: %1!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_READ_KEY
+Language=English
+%2!05u! Opened key for read: %1!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_DELETE_KEY
+Language=English
+%2!05u! Deleted key: %1!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_DELETE_TEMP_KEY
+Language=English
+%2!05u! Deleted key: %1!ws! (temporary)
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_SET_KEY_VALUE
+Language=English
+%3!05u! Set value (%1!ws!) for key: %2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_DELETE_KEY_VALUE
+Language=English
+%3!05u! Deleted value (%1!ws!) for key: %2!ws!
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_DELETE_KEY_TEMP_VALUE
+Language=English
+%3!05u! Deleted value (%1!ws!) for key: %2!ws! (temporary)
+.
+
+MessageId= Severity=Informational Facility=Application SymbolicName=INSTALER_EVENT_GETVERSION
+Language=English
+%2!05u! GetVersion will return %1!ws!
+.
+
+;#endif // _INSTALER_ERRORMSG_
diff --git a/private/sdktools/instaler/event.c b/private/sdktools/instaler/event.c
new file mode 100644
index 000000000..492504f63
--- /dev/null
+++ b/private/sdktools/instaler/event.c
@@ -0,0 +1,76 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    event.c
+
+Abstract:
+
+    Log formatted events to a file and possibly the console too
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+VOID
+CDECL
+LogEvent(
+    UINT MessageId,
+    UINT NumberOfArguments,
+    ...
+    )
+{
+    va_list arglist;
+    HMODULE ModuleHandle;
+    DWORD Flags, Size;
+    WCHAR MessageBuffer[ 512 ];
+    PWSTR s;
+    ULONG Args[ 24 ];
+    PULONG p;
+
+    va_start( arglist, NumberOfArguments );
+    p = Args;
+    while (NumberOfArguments--) {
+        *p++ = va_arg( arglist, ULONG );
+        }
+    *p++ = ((GetTickCount() - StartProcessTickCount) / 1000);   // Seconds since the start
+    *p++ = 0;
+    va_end( arglist );
+
+    Size = FormatMessageW( FORMAT_MESSAGE_FROM_HMODULE | FORMAT_MESSAGE_ARGUMENT_ARRAY,
+                           (LPCVOID)InstalerModuleHandle,
+                           MessageId,
+                           0,
+                           MessageBuffer,
+                           sizeof( MessageBuffer ) / sizeof( WCHAR ),
+                           (va_list *)Args
+                         );
+    if (Size != 0) {
+        s = MessageBuffer;
+        while (s = wcschr( s, L'\r' )) {
+            if (s[1] == '\n') {
+                wcscpy( s, s+1 );
+                }
+            else {
+                s += 1;
+                }
+            }
+        printf( "%ws", MessageBuffer );
+        if (InstalerLogFile) {
+            fprintf( InstalerLogFile, "%ws", MessageBuffer );
+            }
+        }
+    else {
+        printf( "INSTALER: Unable to get message text for %08x\n", MessageId );
+        }
+
+    return;
+}
diff --git a/private/sdktools/instaler/file.bmp b/private/sdktools/instaler/file.bmp
new file mode 100644
index 000000000..24824e130
--- /dev/null
+++ b/private/sdktools/instaler/file.bmp
diff --git a/private/sdktools/instaler/file.c b/private/sdktools/instaler/file.c
new file mode 100644
index 000000000..ea310c54c
--- /dev/null
+++ b/private/sdktools/instaler/file.c
@@ -0,0 +1,440 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    file.c
+
+Abstract:
+
+    This module implements the functions to save references to files for the
+    INSTALER program.  Part of each reference is a handle to a backup copy
+    of a file if the reference is a write/delete/rename.
+
+Author:
+
+    Steve Wood (stevewo) 22-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+
+BOOLEAN
+CreateFileReference(
+    PWSTR Name,
+    BOOLEAN WriteAccess,
+    PFILE_REFERENCE *ReturnedReference
+    )
+{
+    PFILE_REFERENCE p;
+    PWSTR BackupFileName;
+    WIN32_FIND_DATAW FindFileData;
+    HANDLE FindFileHandle;
+
+    *ReturnedReference = NULL;
+    p = FindFileReference( Name );
+    if (p != NULL) {
+        if (p->WriteAccess) {
+            *ReturnedReference = p;
+            return TRUE;
+            }
+        }
+    else {
+        p = AllocMem( sizeof( *p ) );
+        if (p == NULL) {
+            return FALSE;
+            }
+
+        InsertTailList( &FileReferenceListHead, &p->Entry );
+        NumberOfFileReferences += 1;
+        p->Name = Name;
+        }
+
+    BackupFileName = L"";
+    FindFileHandle = NULL;
+    if ((p->WriteAccess = WriteAccess) &&
+        (FindFileHandle = FindFirstFileW( p->Name, &FindFileData )) != INVALID_HANDLE_VALUE
+       ) {
+        if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+            p->DirectoryFile = TRUE;
+            }
+        else {
+            p->BackupFileAttributes = FindFileData.dwFileAttributes;
+            p->BackupLastWriteTime = FindFileData.ftLastWriteTime;
+            p->BackupFileSize.LowPart = FindFileData.nFileSizeLow;
+            p->BackupFileSize.HighPart = FindFileData.nFileSizeHigh;
+            BackupFileName = CreateBackupFileName( &p->BackupFileUniqueId );
+            if (BackupFileName == NULL ||
+                !CopyFileW( Name, BackupFileName, TRUE )
+               ) {
+                p->BackupFileUniqueId = 0xFFFF;     // Backup failed.
+                DeclareError( INSTALER_CANT_ACCESS_FILE, GetLastError(), Name );
+                }
+            }
+        }
+    else {
+        p->Created = p->WriteAccess;
+        }
+
+    if (FindFileHandle != NULL) {
+        FindClose( FindFileHandle );
+        }
+
+    *ReturnedReference = p;
+    return TRUE;
+}
+
+
+BOOLEAN
+CompleteFileReference(
+    PFILE_REFERENCE p,
+    BOOLEAN CallSuccessful,
+    BOOLEAN Deleted,
+    PFILE_REFERENCE RenameReference
+    )
+{
+    DWORD dwFileAttributes;
+
+    if (!CallSuccessful) {
+        DestroyFileReference( p );
+        return FALSE;
+        }
+
+    if (RenameReference) {
+        if (RenameReference->Created) {
+            LogEvent( INSTALER_EVENT_RENAME_TEMP_FILE,
+                      3,
+                      RenameReference->DirectoryFile ? L"directory" : L"file",
+                      RenameReference->Name,
+                      p->Name
+                    );
+
+            RenameReference->Name = p->Name;
+            DestroyFileReference( p );
+            return FALSE;
+            }
+
+        RenameReference->Deleted = TRUE;
+
+        LogEvent( INSTALER_EVENT_RENAME_FILE,
+                  3,
+                  RenameReference->DirectoryFile ? L"directory" : L"file",
+                  RenameReference->Name,
+                  p->Name
+                );
+        }
+    else
+    if (Deleted && p->Created) {
+        LogEvent( INSTALER_EVENT_DELETE_TEMP_FILE,
+                  2,
+                  p->DirectoryFile ? L"directory" : L"file",
+                  p->Name
+                );
+        DestroyFileReference( p );
+        return FALSE;
+        }
+    else {
+        if (wcschr( p->Name, '\\' ) == NULL) {
+            //
+            // If no path separator, must be volume open.  Treat
+            // as directory and dont touch file
+            //
+            p->DirectoryFile = TRUE;
+            }
+        else
+        if ((dwFileAttributes = GetFileAttributes( p->Name )) != 0xFFFFFFFF) {
+            p->DirectoryFile = (dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0;
+            }
+
+        if (Deleted) {
+            LogEvent( INSTALER_EVENT_DELETE_FILE,
+                      2,
+                      p->DirectoryFile ? L"directory" : L"file",
+                      p->Name
+                    );
+            }
+        else
+        if (p->WriteAccess) {
+            if (p->Created) {
+                LogEvent( INSTALER_EVENT_CREATE_FILE,
+                          2,
+                          p->DirectoryFile ? L"directory" : L"file",
+                          p->Name
+                        );
+                }
+            else {
+                LogEvent( INSTALER_EVENT_WRITE_FILE,
+                          2,
+                          p->DirectoryFile ? L"directory" : L"file",
+                          p->Name
+                        );
+                }
+            }
+        else {
+            LogEvent( INSTALER_EVENT_READ_FILE,
+                      2,
+                      p->DirectoryFile ? L"directory" : L"file",
+                      p->Name
+                    );
+            }
+        }
+
+    p->Deleted = Deleted;
+    return TRUE;
+}
+
+
+BOOLEAN
+DestroyFileReference(
+    PFILE_REFERENCE p
+    )
+{
+    PWSTR BackupFileName;
+
+    if (!p->Created &&
+        (BackupFileName = FormatTempFileName( NULL, &p->BackupFileUniqueId ))
+       ) {
+        DeleteFileW( BackupFileName );
+        }
+
+    if (p->DateModified || p->AttributesModified) {
+        return FALSE;
+        }
+
+    RemoveEntryList( &p->Entry );
+    NumberOfFileReferences -= 1;
+    FreeMem( &p );
+    return TRUE;
+}
+
+
+
+PVOID
+MapFileForRead(
+    PWSTR FileName,
+    PULONG FileSize
+    )
+{
+    HANDLE FileHandle, MappingHandle;
+    PVOID FileData;
+    ULONG HighFileSize;
+
+    FileData = NULL;
+    FileHandle = CreateFileW( FileName,
+                              GENERIC_READ,
+                              FILE_SHARE_READ | FILE_SHARE_WRITE,
+                              NULL,
+                              OPEN_EXISTING,
+                              0,
+                              NULL
+                            );
+    if (FileHandle != INVALID_HANDLE_VALUE) {
+        *FileSize = GetFileSize( FileHandle, &HighFileSize );
+        if (*FileSize == 0) {
+            CloseHandle( FileHandle );
+            return (PVOID)0xFFFFFFFF;
+            }
+
+        MappingHandle = CreateFileMappingW( FileHandle,
+                                            NULL,
+                                            PAGE_READONLY,
+                                            0,
+                                            *FileSize,
+                                            NULL
+                                          );
+        CloseHandle( FileHandle );
+        if (MappingHandle != NULL) {
+            FileData = MapViewOfFile( MappingHandle,
+                                      FILE_MAP_READ,
+                                      0,
+                                      0,
+                                      *FileSize
+                                    );
+            CloseHandle( MappingHandle );
+            }
+        }
+
+    return FileData;
+}
+
+
+BOOLEAN
+AreFileContentsEqual(
+    PWSTR FileName1,
+    PWSTR FileName2
+    )
+{
+    PVOID FileData1, FileData2;
+    ULONG FileSize1, FileSize2;
+    BOOLEAN Result;
+
+    Result = FALSE;
+    if (FileData1 = MapFileForRead( FileName1, &FileSize1 )) {
+        if (FileData2 = MapFileForRead( FileName2, &FileSize2 )) {
+            if (FileSize1 == FileSize2 &&
+                RtlCompareMemory( FileData1, FileData2, FileSize1 ) == FileSize1
+               ) {
+                Result = TRUE;
+                }
+            if (FileData2 != (PVOID)0xFFFFFFFF) {
+                UnmapViewOfFile( FileData2 );
+                }
+            }
+        else {
+            DeclareError( INSTALER_CANT_ACCESS_FILE, GetLastError(), FileName2 );
+            }
+
+        if (FileData1 != (PVOID)0xFFFFFFFF) {
+            UnmapViewOfFile( FileData1 );
+            }
+        }
+    else {
+        DeclareError( INSTALER_CANT_ACCESS_FILE, GetLastError(), FileName1 );
+        }
+
+    return Result;
+}
+
+BOOLEAN
+IsNewFileSameAsBackup(
+    PFILE_REFERENCE p
+    )
+{
+    WIN32_FIND_DATAW FindFileData;
+    HANDLE FindFileHandle;
+    PWSTR BackupFileName;
+
+    if ((FindFileHandle = FindFirstFileW( p->Name, &FindFileData )) != INVALID_HANDLE_VALUE) {
+        FindClose( FindFileHandle );
+        if (p->BackupFileAttributes != FindFileData.dwFileAttributes) {
+            p->AttributesModified = TRUE;
+            }
+
+        if (p->BackupLastWriteTime.dwLowDateTime != FindFileData.ftLastWriteTime.dwLowDateTime ||
+            p->BackupLastWriteTime.dwHighDateTime != FindFileData.ftLastWriteTime.dwHighDateTime
+           ) {
+            p->DateModified = TRUE;
+            }
+
+        if (BackupFileName = FormatTempFileName( NULL, &p->BackupFileUniqueId )) {
+            if (p->BackupFileSize.LowPart != FindFileData.nFileSizeLow ||
+                p->BackupFileSize.HighPart != FindFileData.nFileSizeHigh ||
+                !AreFileContentsEqual( BackupFileName, p->Name )
+               ) {
+                p->ContentsModified = TRUE;
+                return FALSE;
+                }
+            }
+
+        return TRUE;
+        }
+    else {
+        return FALSE;
+        }
+}
+
+PFILE_REFERENCE
+FindFileReference(
+    PWSTR Name
+    )
+{
+    PFILE_REFERENCE p;
+    PLIST_ENTRY Head, Next;
+
+    Head = &FileReferenceListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, FILE_REFERENCE, Entry );
+        if (p->Name == Name) {
+            return p;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+
+VOID
+DumpFileReferenceList(
+    FILE *LogFile
+    )
+{
+    PFILE_REFERENCE p;
+    PLIST_ENTRY Head, Next;
+
+    Head = &FileReferenceListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, FILE_REFERENCE, Entry );
+        if (p->WriteAccess) {
+            if (!p->Deleted) {
+                if (p->BackupFileUniqueId == 0) {
+                    if (p->Created) {
+                        ImlAddFileRecord( pImlNew,
+                                          CreateNewFile,
+                                          p->Name,
+                                          NULL,
+                                          NULL,
+                                          0
+                                        );
+                        }
+                    }
+                else {
+                    if (p->ContentsModified) {
+                        if (ImlAddFileRecord( pImlNew,
+                                              ModifyOldFile,
+                                              p->Name,
+                                              FormatTempFileName( NULL, &p->BackupFileUniqueId ),
+                                              NULL,
+                                              0
+                                            )
+                           ) {
+                            DeleteFile( FormatTempFileName( NULL, &p->BackupFileUniqueId ) );
+                            }
+                        }
+                    else
+                    if (p->DateModified) {
+                        ImlAddFileRecord( pImlNew,
+                                          ModifyFileDateTime,
+                                          p->Name,
+                                          NULL,
+                                          &p->BackupLastWriteTime,
+                                          p->BackupFileAttributes
+                                        );
+                        }
+                    else {
+                        ImlAddFileRecord( pImlNew,
+                                          ModifyFileAttributes,
+                                          p->Name,
+                                          NULL,
+                                          &p->BackupLastWriteTime,
+                                          p->BackupFileAttributes
+                                        );
+                        }
+                    }
+                }
+            else {
+                if (ImlAddFileRecord( pImlNew,
+                                      DeleteOldFile,
+                                      p->Name,
+                                      FormatTempFileName( NULL, &p->BackupFileUniqueId ),
+                                      NULL,
+                                      0
+                                    )
+                   ) {
+                    DeleteFile( FormatTempFileName( NULL, &p->BackupFileUniqueId ) );
+                    }
+                }
+            }
+
+        Next = Next->Flink;
+        }
+
+    return;
+}
diff --git a/private/sdktools/instaler/fileman.c b/private/sdktools/instaler/fileman.c
new file mode 100644
index 000000000..7ebcd0f2f
--- /dev/null
+++ b/private/sdktools/instaler/fileman.c
@@ -0,0 +1,226 @@
+#include <windows.h>
+#include <stdlib.h>
+#include <string.h>
+#include "resource.h"
+#include "hlist.h"
+
+
+#define TYPE_FILE  1
+#define TYPE_DIR   2
+
+
+LRESULT WndProc(HWND,UINT,WPARAM,LPARAM);
+
+HINSTANCE  hControlLib;
+HINSTANCE  hInst;
+HBITMAP    hFileBmp;
+HBITMAP    hDirBmp;
+HWND       hwndList;
+
+
+BOOL HListInitialize(HMODULE);
+
+
+
+int _cdecl
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    WNDCLASS    wndclass;
+    HWND        hwnd;
+    MSG         msg;
+
+
+    hInst = GetModuleHandle( NULL );
+
+    HListInitialize( hInst );
+
+    hFileBmp = LoadBitmap( hInst, MAKEINTRESOURCE(FILEBMP) );
+    hDirBmp  = LoadBitmap( hInst, MAKEINTRESOURCE(DIRBMP) );
+
+    wndclass.style         = CS_HREDRAW | CS_VREDRAW;
+    wndclass.lpfnWndProc   = WndProc;
+    wndclass.cbClsExtra    = 0;
+    wndclass.cbWndExtra    = 0;
+    wndclass.hInstance     = hInst;
+    wndclass.hIcon         = LoadIcon (NULL, IDI_APPLICATION);
+    wndclass.hCursor       = LoadCursor (NULL, IDC_ARROW);
+    wndclass.hbrBackground = GetStockObject (WHITE_BRUSH);
+    wndclass.lpszMenuName  = NULL;
+    wndclass.lpszClassName = "test";
+    RegisterClass (&wndclass);
+
+    hwnd = CreateWindow(
+        "test",
+        "Test Custon Control App",
+        WS_OVERLAPPEDWINDOW,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        CW_USEDEFAULT,
+        NULL,
+        NULL,
+        GetModuleHandle(NULL),
+        NULL );
+
+    ShowWindow( hwnd, SW_SHOW );
+    UpdateWindow( hwnd );
+
+    while (GetMessage( &msg, NULL, 0, 0 )) {
+        TranslateMessage( &msg );
+        DispatchMessage( &msg );
+    }
+
+    return 0;
+}
+
+DWORD CALLBACK
+ExpansionCallback(
+    LPDWORD type,
+    LPSTR   *str,
+    LPSTR   ref,
+    DWORD   level,
+    DWORD   nchild
+    )
+{
+    static WIN32_FIND_DATA fd = {0};
+    static HANDLE          hFind = NULL;
+    static CHAR            Dir[MAX_PATH*3];
+    CHAR                   NewDir[MAX_PATH*3];
+    LPSTR                  p;
+
+
+    if ((!hFind) && (*type == TYPE_FILE)) {
+        MessageBeep( 0 );
+        return HLB_END;
+    }
+
+    if (!hFind) {
+        if (nchild) {
+            //
+            // this node needs to be collapsed
+            //
+            return HLB_COLLAPSE;
+        }
+
+        if (!GetCurrentDirectory( sizeof(Dir), Dir )) {
+            return HLB_IGNORE;
+        }
+        p = ref;
+        NewDir[0] = 0;
+        while (p && *p) {
+            p += (strlen(p) + 1);
+        }
+        while (p != ref) {
+            p -= 2;
+            while (*p && p != ref) {
+                p--;
+            }
+            if (!*p) {
+                p++;
+            }
+            strcat( NewDir, p );
+            strcat( NewDir, "\\" );
+        }
+        if (!SetCurrentDirectory( NewDir )) {
+            return HLB_END;
+        }
+        hFind = FindFirstFile( "*.*", &fd );
+        if (hFind == INVALID_HANDLE_VALUE) {
+            hFind = NULL;
+            MessageBeep( 0 );
+            return HLB_END;
+        }
+    } else {
+        if (!FindNextFile( hFind, &fd )) {
+            FindClose( hFind );
+            SetCurrentDirectory( Dir );
+            hFind = NULL;
+            return HLB_END;
+        }
+    }
+
+
+    *str = fd.cFileName;
+
+    if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+        *type = TYPE_DIR;
+    } else {
+        *type = TYPE_FILE;
+    }
+
+    if (level && fd.cFileName[0] == '.') {
+        return HLB_IGNORE;
+    }
+
+    return HLB_EXPAND;
+}
+
+VOID
+FillListBox(
+    VOID
+    )
+{
+    WIN32_FIND_DATA fd;
+    HANDLE          hFind;
+    DWORD           type;
+
+
+    hFind = FindFirstFile( "*.*", &fd );
+    if (hFind == INVALID_HANDLE_VALUE) {
+        return;
+    }
+
+    do {
+        if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+            type = TYPE_DIR;
+        } else {
+            type = TYPE_FILE;
+        }
+        SendMessage( hwndList, HLB_ADDSTRING, type, (LPARAM) fd.cFileName );
+    } while(FindNextFile( hFind, &fd ));
+
+    FindClose( hFind );
+}
+
+LRESULT
+WndProc(
+    HWND    hwnd,
+    UINT    message,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    RECT cRect;
+
+
+    switch (message) {
+        case WM_CREATE:
+            GetClientRect( hwnd, &cRect );
+            hwndList = CreateWindow(
+                "HList",
+                NULL,
+                WS_CHILD | WS_VISIBLE,
+                cRect.left,
+                cRect.top,
+                cRect.right  - cRect.left,
+                cRect.bottom - cRect.top,
+                hwnd,
+                NULL,
+                GetModuleHandle(NULL),
+                NULL );
+            SendMessage( hwndList, HLB_REGISTER_CALLBACK, 0, (LPARAM)ExpansionCallback );
+            SendMessage( hwndList, HLB_REGISTER_TYPE, TYPE_FILE, (LPARAM)hFileBmp );
+            SendMessage( hwndList, HLB_REGISTER_TYPE, TYPE_DIR, (LPARAM)hDirBmp );
+            FillListBox();
+            break;
+
+        case WM_DESTROY:
+            PostQuitMessage( 0 );
+            return 0;
+    }
+
+    return DefWindowProc( hwnd, message, wParam, lParam );
+}
diff --git a/private/sdktools/instaler/handledb.c b/private/sdktools/instaler/handledb.c
new file mode 100644
index 000000000..f3ade0c56
--- /dev/null
+++ b/private/sdktools/instaler/handledb.c
@@ -0,0 +1,172 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    handledb.c
+
+Abstract:
+
+    This module contains the code to maintain an open handle data base for the
+    INSTALER program.  This is used to track path names associated with open
+    handles so we can construct full paths from relative opens.
+
+Author:
+
+    Steve Wood (stevewo) 11-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+char *HandleTypes[] = {
+    "File/Key",
+    "File",
+    "Key"
+};
+
+POPENHANDLE_INFO
+FindOpenHandle(
+    PPROCESS_INFO Process,
+    HANDLE Handle,
+    ULONG Type
+    )
+{
+    PLIST_ENTRY Next, Head;
+    POPENHANDLE_INFO p;
+
+    Head = &Process->OpenHandleListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        p = CONTAINING_RECORD( Next, OPENHANDLE_INFO, Entry );
+        if (p->Handle == Handle && (Type == (ULONG)-1 || p->Type == Type)) {
+            return p;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+BOOLEAN
+AddOpenHandle(
+    PPROCESS_INFO Process,
+    HANDLE Handle,
+    ULONG Type,
+    PWSTR Name,
+    BOOLEAN InheritHandle
+    )
+{
+    POPENHANDLE_INFO p;
+
+    if (Type == (ULONG)-1) {
+        return FALSE;
+        }
+
+    if (FindOpenHandle( Process, Handle, Type ) != NULL) {
+        return FALSE;
+        }
+
+    p = AllocMem( sizeof( *p ) );
+    if (p == NULL) {
+        return FALSE;
+        }
+
+    p->Handle = Handle;
+    p->Type = (USHORT)Type;
+    p->Inherit = InheritHandle;
+    p->Name = Name;
+    p->LengthOfName = (USHORT)(wcslen( Name ) * sizeof( WCHAR ));
+    if (Type == HANDLE_TYPE_FILE && p->LengthOfName == (3 * sizeof( WCHAR ))) {
+        p->RootDirectory = TRUE;
+        }
+
+    InsertHeadList( &Process->OpenHandleListHead, &p->Entry );
+
+    return TRUE;
+}
+
+
+BOOLEAN
+DeleteOpenHandle(
+    PPROCESS_INFO Process,
+    HANDLE Handle,
+    ULONG Type
+    )
+{
+    POPENHANDLE_INFO p;
+
+    p = FindOpenHandle( Process, Handle, Type );
+    if (p == NULL) {
+        //
+        // We will see lots of close calls for handles we dont care
+        // about.  Ignore them quietly.
+        //
+        return FALSE;
+        }
+
+    RemoveEntryList( &p->Entry );
+    FreeMem( &p->QueryName );
+    FreeMem( &p );
+    return TRUE;
+}
+
+
+static BOOLEAN IgnoredFirstProcess = FALSE;
+
+VOID
+InheritHandles(
+    PPROCESS_INFO Process
+    )
+{
+    PPROCESS_INFO ParentProcess;
+    PLIST_ENTRY Prev, Head;
+    POPENHANDLE_INFO p;
+
+    if (Process->ProcessInformation.InheritedFromUniqueProcessId == 0) {
+        return;
+        }
+
+    ParentProcess = FindProcessById( Process->ProcessInformation.InheritedFromUniqueProcessId );
+    if (ParentProcess == NULL) {
+        if (!IgnoredFirstProcess) {
+            IgnoredFirstProcess = TRUE;
+            }
+        else {
+            DbgEvent( INTERNALERROR, ("Unable to find parent process (%x)\n", Process->ProcessInformation.InheritedFromUniqueProcessId ) );
+            }
+
+        return;
+        }
+
+    Head = &ParentProcess->OpenHandleListHead;
+    Prev = Head->Blink;
+    while (Prev != Head) {
+        p = CONTAINING_RECORD( Prev, OPENHANDLE_INFO, Entry );
+        if (p->Inherit) {
+            if (!AddOpenHandle( Process,
+                                p->Handle,
+                                p->Type,
+                                p->Name,
+                                TRUE
+                              )
+               ) {
+                DbgEvent( INTERNALERROR, ("Unable to inherit %s handle (%x) for '%ws' from process (%x)\n",
+                                          HandleTypes[ 1+p->Type ],
+                                          p->Handle,
+                                          p->Name,
+                                          Process->ProcessInformation.InheritedFromUniqueProcessId
+                                         )
+                        );
+                }
+            }
+
+        Prev = Prev->Blink;
+        }
+
+    return;
+}
diff --git a/private/sdktools/instaler/handler.c b/private/sdktools/instaler/handler.c
new file mode 100644
index 000000000..f28754648
--- /dev/null
+++ b/private/sdktools/instaler/handler.c
@@ -0,0 +1,2355 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    handler.c
+
+Abstract:
+
+    This module contains the individual API handler routines for the INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 10-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+#include <ntstatus.dbg>
+
+
+BOOLEAN
+HandleBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PBREAKPOINT_INFO Breakpoint
+    )
+{
+    BOOLEAN Result;
+    API_SAVED_PARAMETERS SavedParameters;
+    UCHAR ApiIndex;
+    PBREAKPOINT_INFO ReturnBreakpoint;
+
+    Result = FALSE;
+    ApiIndex = Breakpoint->ApiIndex;
+    if (ApiInfo[ ApiIndex ].ModuleIndex < Thread->ModuleIndexCurrentlyIn) {
+        return TRUE;
+        }
+
+    DbgEvent( DBGEVENT, ( "Processing Breakpoint at %ws!%s\n",
+                          Breakpoint->ModuleName,
+                          Breakpoint->ProcedureName
+                        )
+            );
+
+    if (!Breakpoint->SavedParametersValid) {
+        memset( &SavedParameters, 0, sizeof( SavedParameters ) );
+
+        Result = TRUE;
+        if (ExtractProcedureParameters( Process,
+                                        Thread,
+                                        (PVOID)&SavedParameters.ReturnAddress,
+                                        ApiInfo[ ApiIndex ].SizeOfParameters,
+                                        (PULONG)&SavedParameters.InputParameters
+                                      )
+           ) {
+            if (ApiInfo[ ApiIndex ].EntryPointHandler == NULL ||
+                (ApiInfo[ ApiIndex ].EntryPointHandler)( Process,
+                                                         Thread,
+                                                         &SavedParameters
+                                                       )
+               ) {
+                if (SavedParameters.ReturnAddress == NULL) {
+                    Result = FALSE;
+                    }
+                else
+                if (CreateBreakpoint( SavedParameters.ReturnAddress,
+                                      Process,
+                                      Thread,  // thread specific
+                                      ApiIndex,
+                                      &SavedParameters,
+                                      &ReturnBreakpoint
+                                    )
+                   ) {
+                    ReturnBreakpoint->ModuleName = L"Return from";
+                    ReturnBreakpoint->ProcedureName = Breakpoint->ProcedureName;
+                    Thread->ModuleIndexCurrentlyIn = ApiInfo[ ApiIndex ].ModuleIndex;
+                    }
+                }
+            }
+
+#if DBG
+        TrimTemporaryBuffer();
+#endif
+        }
+    else {
+        if (UndoReturnAddressBreakpoint( Process, Thread ) &&
+            ExtractProcedureReturnValue( Process,
+                                         Thread,
+                                         &Breakpoint->SavedParameters.ReturnValue,
+                                         ApiInfo[ ApiIndex ].SizeOfReturnValue
+                                       )
+           ) {
+            Breakpoint->SavedParameters.ReturnValueValid = TRUE;
+            if (ApiInfo[ ApiIndex ].EntryPointHandler != NULL) {
+                (ApiInfo[ ApiIndex ].EntryPointHandler)( Process,
+                                                         Thread,
+                                                         &Breakpoint->SavedParameters
+                                                       );
+                }
+            }
+
+        Thread->ModuleIndexCurrentlyIn = 0;
+        FreeSavedCallState( &Breakpoint->SavedParameters.SavedCallState );
+        DestroyBreakpoint( Breakpoint->Address, Process, Thread );
+#if DBG
+        TrimTemporaryBuffer();
+#endif
+        Result = FALSE;
+        }
+
+    return Result;
+}
+
+
+BOOLEAN
+CreateSavedCallState(
+    PPROCESS_INFO Process,
+    PAPI_SAVED_CALL_STATE SavedCallState,
+    API_ACTION Action,
+    ULONG Type,
+    PWSTR FullName,
+    ...
+    )
+{
+    va_list arglist;
+
+    va_start( arglist, FullName );
+    SavedCallState->Action = Action;
+    SavedCallState->Type = Type;
+    SavedCallState->FullName = FullName;
+    switch (Action) {
+        case OpenPath:
+            SavedCallState->PathOpen.InheritHandle = va_arg( arglist, BOOLEAN );
+            SavedCallState->PathOpen.WriteAccessRequested = va_arg( arglist, BOOLEAN );
+            SavedCallState->PathOpen.ResultHandleAddress = va_arg( arglist, PHANDLE );
+            break;
+
+        case RenamePath:
+            SavedCallState->PathRename.NewName = va_arg( arglist, PWSTR );
+            SavedCallState->PathRename.ReplaceIfExists = va_arg( arglist, BOOLEAN );
+            break;
+
+        case DeletePath:
+        case QueryPath:
+        case SetValue:
+        case DeleteValue:
+            break;
+
+        case WriteIniValue:
+            SavedCallState->SetIniValue.SectionName = va_arg( arglist, PWSTR );
+            SavedCallState->SetIniValue.VariableName = va_arg( arglist, PWSTR );
+            SavedCallState->SetIniValue.VariableValue = va_arg( arglist, PWSTR );
+            break;
+
+        case WriteIniSection:
+            SavedCallState->SetIniSection.SectionName = va_arg( arglist, PWSTR );
+            SavedCallState->SetIniSection.SectionValue = va_arg( arglist, PWSTR );
+            break;
+
+        default:
+            return FALSE;
+        }
+    va_end( arglist );
+
+    return TRUE;
+}
+
+VOID
+FreeSavedCallState(
+    PAPI_SAVED_CALL_STATE CallState
+    )
+{
+    switch (CallState->Action) {
+        case WriteIniValue:
+            FreeMem( &CallState->SetIniValue.VariableValue );
+            break;
+
+        case WriteIniSection:
+            FreeMem( &CallState->SetIniSection.SectionValue );
+            break;
+        }
+
+    return;
+}
+
+
+
+BOOLEAN
+CaptureObjectAttributes(
+    PPROCESS_INFO Process,
+    POBJECT_ATTRIBUTES ObjectAttributesAddress,
+    POBJECT_ATTRIBUTES ObjectAttributes,
+    PUNICODE_STRING ObjectName
+    )
+{
+    if (ObjectAttributesAddress != NULL &&
+        ReadMemory( Process,
+                    ObjectAttributesAddress,
+                    ObjectAttributes,
+                    sizeof( *ObjectAttributes ),
+                    "object attributes"
+                  ) &&
+        ObjectAttributes->ObjectName != NULL &&
+        ReadMemory( Process,
+                    ObjectAttributes->ObjectName,
+                    ObjectName,
+                    sizeof( *ObjectName ),
+                    "object name string"
+                  )
+       ) {
+        return TRUE;
+        }
+    else {
+        return FALSE;
+        }
+}
+
+BOOLEAN
+CaptureFullName(
+    PPROCESS_INFO Process,
+    ULONG Type,
+    HANDLE RootDirectory,
+    PWSTR Name,
+    ULONG Length,
+    PWSTR *ReturnedFullName
+    )
+{
+    POPENHANDLE_INFO HandleInfo;
+    UNICODE_STRING FullName;
+    ULONG LengthOfName;
+    PWSTR s;
+    BOOLEAN Result;
+
+    *ReturnedFullName = NULL;
+    if (RootDirectory != NULL) {
+        HandleInfo = FindOpenHandle( Process,
+                                     RootDirectory,
+                                     Type
+                                   );
+        if (HandleInfo == NULL) {
+            //
+            // If handle not found then we dont care about this open
+            // as it is relative to a device that is not local.
+            //
+            return FALSE;
+            }
+        }
+    else {
+        HandleInfo = NULL;
+        }
+
+    LengthOfName = Length + sizeof( UNICODE_NULL );
+    if (HandleInfo != NULL) {
+        LengthOfName += HandleInfo->LengthOfName +
+                        sizeof( OBJ_NAME_PATH_SEPARATOR );
+        }
+
+    FullName.Buffer = AllocMem( LengthOfName );
+    if (FullName.Buffer == NULL) {
+        return FALSE;
+        }
+
+    s = FullName.Buffer;
+    if (HandleInfo != NULL) {
+        RtlMoveMemory( s,
+                       HandleInfo->Name,
+                       HandleInfo->LengthOfName
+                     );
+        s = &FullName.Buffer[ HandleInfo->LengthOfName / sizeof( WCHAR ) ];
+        if (s[-1] != OBJ_NAME_PATH_SEPARATOR) {
+            *s++ = OBJ_NAME_PATH_SEPARATOR;
+            }
+        }
+
+    if (!ReadMemory( Process,
+                     Name,
+                     s,
+                     Length,
+                     "object name buffer"
+                   )
+       ) {
+        FreeMem( &FullName.Buffer );
+        return FALSE;
+        }
+
+    s = &s[ Length / sizeof( WCHAR ) ];
+    *s = UNICODE_NULL;
+    FullName.Length = (PCHAR)s - (PCHAR)FullName.Buffer;
+    FullName.MaximumLength = (USHORT)(FullName.Length + sizeof( UNICODE_NULL ));
+    if (HandleInfo == NULL && Type == HANDLE_TYPE_FILE) {
+        Result = IsDriveLetterPath( &FullName );
+        }
+    else {
+        Result = TRUE;
+        }
+    *ReturnedFullName = AddName( &FullName );
+    FreeMem( &FullName.Buffer );
+    return Result;
+}
+
+
+BOOLEAN
+CaptureOpenState(
+    PPROCESS_INFO Process,
+    PAPI_SAVED_PARAMETERS Parameters,
+    POBJECT_ATTRIBUTES ObjectAttributesAddress,
+    BOOLEAN WriteAccess,
+    PHANDLE ResultHandleAddress,
+    ULONG Type
+    )
+{
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    UNICODE_STRING ObjectName;
+    PWSTR FullName;
+    BOOLEAN Result;
+
+    Result = FALSE;
+    if (CaptureObjectAttributes( Process,
+                                 ObjectAttributesAddress,
+                                 &ObjectAttributes,
+                                 &ObjectName
+                               ) &&
+        CaptureFullName( Process,
+                         Type,
+                         ObjectAttributes.RootDirectory,
+                         ObjectName.Buffer,
+                         ObjectName.Length,
+                         &FullName
+                       ) &&
+        CreateSavedCallState( Process,
+                              &Parameters->SavedCallState,
+                              OpenPath,
+                              Type,
+                              FullName,
+                              (BOOLEAN)((ObjectAttributes.Attributes & OBJ_INHERIT) != 0),
+                              WriteAccess,
+                              ResultHandleAddress
+                            )
+       ) {
+        if (Type == HANDLE_TYPE_FILE) {
+            Result = CreateFileReference( FullName,
+                                          Parameters->SavedCallState.PathOpen.WriteAccessRequested,
+                                          (PFILE_REFERENCE *)&Parameters->SavedCallState.Reference
+                                        );
+            }
+        else {
+            Result = CreateKeyReference( FullName,
+                                         Parameters->SavedCallState.PathOpen.WriteAccessRequested,
+                                         (PKEY_REFERENCE *)&Parameters->SavedCallState.Reference
+                                       );
+            }
+        }
+
+    return Result;
+}
+
+
+BOOLEAN
+CompleteOpenState(
+    PPROCESS_INFO Process,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PAPI_SAVED_CALL_STATE p = &Parameters->SavedCallState;
+    HANDLE Handle;
+    BOOLEAN CallSuccessful;
+    PFILE_REFERENCE FileReference;
+    PKEY_REFERENCE KeyReference;
+
+    if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong ) &&
+        ReadMemory( Process,
+                    p->PathOpen.ResultHandleAddress,
+                    &Handle,
+                    sizeof( Handle ),
+                    "result handle"
+                  ) &&
+        AddOpenHandle( Process,
+                       Handle,
+                       p->Type,
+                       p->FullName,
+                       p->PathOpen.InheritHandle
+                     )
+       ) {
+        CallSuccessful = TRUE;
+        }
+    else {
+        CallSuccessful = FALSE;
+        }
+    IncrementOpenCount( p->FullName, CallSuccessful );
+
+    if (p->Type == HANDLE_TYPE_FILE) {
+        FileReference = (PFILE_REFERENCE)p->Reference;
+        CompleteFileReference( FileReference,
+                               CallSuccessful,
+                               FALSE,
+                               NULL
+                             );
+        }
+    else
+    if (p->Type == HANDLE_TYPE_KEY) {
+        KeyReference = (PKEY_REFERENCE)p->Reference;
+        CompleteKeyReference( (PKEY_REFERENCE)p->Reference,
+                              CallSuccessful,
+                              FALSE
+                            );
+        }
+
+    return TRUE;
+}
+
+#if TRACE_ENABLED
+
+
+ENUM_TYPE_NAMES FileAccessNames[] = {
+    FILE_READ_DATA,                 "FILE_READ_DATA",
+    FILE_READ_DATA,                 "FILE_READ_DATA",
+    FILE_WRITE_DATA,                "FILE_WRITE_DATA",
+    FILE_APPEND_DATA,               "FILE_APPEND_DATA",
+    FILE_READ_EA,                   "FILE_READ_EA",
+    FILE_WRITE_EA,                  "FILE_WRITE_EA",
+    FILE_EXECUTE,                   "FILE_EXECUTE",
+    FILE_DELETE_CHILD,              "FILE_DELETE_CHILD",
+    FILE_READ_ATTRIBUTES,           "FILE_READ_ATTRIBUTES",
+    FILE_WRITE_ATTRIBUTES,          "FILE_WRITE_ATTRIBUTES",
+    DELETE,                         "DELETE",
+    READ_CONTROL,                   "READ_CONTROL",
+    WRITE_DAC,                      "WRITE_DAC",
+    WRITE_OWNER,                    "WRITE_OWNER",
+    SYNCHRONIZE,                    "SYNCHRONIZE",
+    GENERIC_READ,                   "GENERIC_READ",
+    GENERIC_WRITE,                  "GENERIC_WRITE",
+    GENERIC_EXECUTE,                "GENERIC_EXECUTE",
+    GENERIC_ALL,                    "GENERIC_ALL",
+    0xFFFFFFFF,                     "%x"
+};
+
+
+ENUM_TYPE_NAMES FileShareNames[] = {
+    FILE_SHARE_READ,                "FILE_SHARE_READ",
+    FILE_SHARE_WRITE,               "FILE_SHARE_WRITE",
+    FILE_SHARE_DELETE,              "FILE_SHARE_DELETE",
+    0xFFFFFFFF,                     "FILE_SHARE_NONE"
+};
+
+ENUM_TYPE_NAMES FileCreateDispositionNames[] = {
+    FILE_SUPERSEDE,                 "FILE_SUPERSEDE",
+    FILE_OPEN,                      "FILE_OPEN",
+    FILE_CREATE,                    "FILE_CREATE",
+    FILE_OPEN_IF,                   "FILE_OPEN_IF",
+    FILE_OVERWRITE,                 "FILE_OVERWRITE",
+    FILE_OVERWRITE_IF,              "FILE_OVERWRITE_IF",
+    0xFFFFFFFF,                     "%x"
+};
+
+ENUM_TYPE_NAMES FileCreateOptionNames[] = {
+    FILE_DIRECTORY_FILE,            "FILE_DIRECTORY_FILE",
+    FILE_WRITE_THROUGH,             "FILE_WRITE_THROUGH",
+    FILE_SEQUENTIAL_ONLY,           "FILE_SEQUENTIAL_ONLY",
+    FILE_NO_INTERMEDIATE_BUFFERING, "FILE_NO_INTERMEDIATE_BUFFERING",
+    FILE_SYNCHRONOUS_IO_ALERT,      "FILE_SYNCHRONOUS_IO_ALERT",
+    FILE_SYNCHRONOUS_IO_NONALERT,   "FILE_SYNCHRONOUS_IO_NONALERT",
+    FILE_NON_DIRECTORY_FILE,        "FILE_NON_DIRECTORY_FILE",
+    FILE_CREATE_TREE_CONNECTION,    "FILE_CREATE_TREE_CONNECTION",
+    FILE_COMPLETE_IF_OPLOCKED,      "FILE_COMPLETE_IF_OPLOCKED",
+    FILE_NO_EA_KNOWLEDGE,           "FILE_NO_EA_KNOWLEDGE",
+    FILE_RANDOM_ACCESS,             "FILE_RANDOM_ACCESS",
+    FILE_DELETE_ON_CLOSE,           "FILE_DELETE_ON_CLOSE",
+    FILE_OPEN_BY_FILE_ID,           "FILE_OPEN_BY_FILE_ID",
+    FILE_OPEN_FOR_BACKUP_INTENT,    "FILE_OPEN_FOR_BACKUP_INTENT",
+    FILE_NO_COMPRESSION,            "FILE_NO_COMPRESSION",
+    0xFFFFFFFF,                     "%x"
+};
+
+
+ENUM_TYPE_NAMES FileIoStatusInfoNames[] = {
+    FILE_SUPERSEDED,                "FILE_SUPERSEDED",
+    FILE_OPENED,                    "FILE_OPENED",
+    FILE_CREATED,                   "FILE_CREATED",
+    FILE_OVERWRITTEN,               "FILE_OVERWRITTEN",
+    FILE_EXISTS,                    "FILE_EXISTS",
+    FILE_DOES_NOT_EXIST,            "FILE_DOES_NOT_EXIST",
+    0xFFFFFFFF,                     "%x"
+};
+
+
+ENUM_TYPE_NAMES SetFileInfoClassNames[] = {
+    FileDirectoryInformation,       "FileDirectoryInformation",
+    FileFullDirectoryInformation,   "FileFullDirectoryInformation",
+    FileBothDirectoryInformation,   "FileBothDirectoryInformation",
+    FileBasicInformation,           "FileBasicInformation",
+    FileStandardInformation,        "FileStandardInformation",
+    FileInternalInformation,        "FileInternalInformation",
+    FileEaInformation,              "FileEaInformation",
+    FileAccessInformation,          "FileAccessInformation",
+    FileNameInformation,            "FileNameInformation",
+    FileRenameInformation,          "FileRenameInformation",
+    FileLinkInformation,            "FileLinkInformation",
+    FileNamesInformation,           "FileNamesInformation",
+    FileDispositionInformation,     "FileDispositionInformation",
+    FilePositionInformation,        "FilePositionInformation",
+    FileFullEaInformation,          "FileFullEaInformation",
+    FileModeInformation,            "FileModeInformation",
+    FileAlignmentInformation,       "FileAlignmentInformation",
+    FileAllInformation,             "FileAllInformation",
+    FileAllocationInformation,      "FileAllocationInformation",
+    FileEndOfFileInformation,       "FileEndOfFileInformation",
+    FileAlternateNameInformation,   "FileAlternateNameInformation",
+    FileStreamInformation,          "FileStreamInformation",
+    FilePipeInformation,            "FilePipeInformation",
+    FilePipeLocalInformation,       "FilePipeLocalInformation",
+    FilePipeRemoteInformation,      "FilePipeRemoteInformation",
+    FileMailslotQueryInformation,   "FileMailslotQueryInformation",
+    FileMailslotSetInformation,     "FileMailslotSetInformation",
+    FileCompressionInformation,     "FileCompressionInformation",
+    FileCopyOnWriteInformation,     "FileCopyOnWriteInformation",
+    FileCompletionInformation,      "FileCompletionInformation",
+    FileMoveClusterInformation,     "FileMoveClusterInformation",
+    0xFFFFFFFF,                     "%x"
+};
+
+ENUM_TYPE_NAMES KeyCreateOptionNames[] = {
+    REG_OPTION_VOLATILE,            "REG_OPTION_VOLATILE",
+    REG_OPTION_CREATE_LINK,         "REG_OPTION_CREATE_LINK",
+    REG_OPTION_BACKUP_RESTORE,      "REG_OPTION_BACKUP_RESTORE",
+    0xFFFFFFFF,                     "%x"
+};
+
+ENUM_TYPE_NAMES KeyDispositionNames[] = {
+    REG_CREATED_NEW_KEY,            "REG_CREATED_NEW_KEY",
+    REG_OPENED_EXISTING_KEY,        "REG_OPENED_EXISTING_KEY",
+    0xFFFFFFFF,                     "%x"
+};
+
+
+#endif // TRACE_ENABLED
+
+BOOLEAN
+IsFileWriteAccessRequested(
+    ACCESS_MASK DesiredAccess,
+    ULONG CreateDisposition
+    )
+{
+    if (DesiredAccess & (GENERIC_WRITE |
+                         GENERIC_ALL |
+                         DELETE |
+                         FILE_WRITE_DATA |
+                         FILE_APPEND_DATA
+                        )
+       ) {
+        return TRUE;
+        }
+
+    if (CreateDisposition != FILE_OPEN && CreateDisposition != FILE_OPEN_IF) {
+        return TRUE;
+        }
+
+    return FALSE;
+}
+
+BOOLEAN
+NtCreateFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PCREATEFILE_PARAMETERS p = &Parameters->InputParameters.CreateFile;
+    BOOLEAN Result;
+
+    if (!Parameters->ReturnValueValid) {
+        Result = CaptureOpenState( Process,
+                                   Parameters,
+                                   p->ObjectAttributes,
+                                   IsFileWriteAccessRequested( p->DesiredAccess, p->CreateDisposition ),
+                                   p->FileHandle,
+                                   HANDLE_TYPE_FILE
+                                 );
+
+
+        if (Result
+            // && Parameters->SavedCallState.PathOpen.WriteAccessRequested
+           ) {
+            DbgEvent( CREATEEVENT, ( "NtCreateFile called:\n"
+                                     "    Name:   %ws\n"
+                                     "    Access: %s\n"
+                                     "    Share:  %s\n"
+                                     "    Create: %s\n"
+                                     "    Options:%s\n",
+                                     Parameters->SavedCallState.FullName,
+                                     FormatEnumType( 0,
+                                                     FileAccessNames,
+                                                     p->DesiredAccess,
+                                                     TRUE
+                                                   ),
+                                     FormatEnumType( 1,
+                                                     FileShareNames,
+                                                     p->ShareAccess,
+                                                     TRUE
+                                                   ),
+                                     FormatEnumType( 2,
+                                                     FileCreateDispositionNames,
+                                                     p->CreateDisposition,
+                                                     FALSE
+                                                   ),
+                                     FormatEnumType( 3,
+                                                     FileCreateOptionNames,
+                                                     p->CreateOptions,
+                                                     TRUE
+                                                   )
+                                   )
+                    );
+            }
+        }
+    else {
+        Result = CompleteOpenState( Process,
+                                    Parameters
+                                  );
+        if (Result
+            // && Parameters->SavedCallState.PathOpen.WriteAccessRequested
+           ) {
+            IO_STATUS_BLOCK IoStatusBlock;
+
+            ReadMemory( Process,
+                        p->IoStatusBlock,
+                        &IoStatusBlock,
+                        sizeof( IoStatusBlock ),
+                        "IoStatusBlock"
+                      );
+            DbgEvent( CREATEEVENT, ( "*** Returned %s [%s %s]\n",
+                                     FormatEnumType( 0,
+                                                     (PENUM_TYPE_NAMES)ntstatusSymbolicNames,
+                                                     Parameters->ReturnValue.ReturnedLong,
+                                                     FALSE
+                                                   ),
+                                     FormatEnumType( 1,
+                                                     (PENUM_TYPE_NAMES)ntstatusSymbolicNames,
+                                                     IoStatusBlock.Status,
+                                                     FALSE
+                                                   ),
+                                     FormatEnumType( 2,
+                                                     FileIoStatusInfoNames,
+                                                     IoStatusBlock.Information,
+                                                     FALSE
+                                                   )
+                                   )
+                    );
+            }
+        }
+
+    return Result;
+}
+
+BOOLEAN
+NtOpenFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    POPENFILE_PARAMETERS p = &Parameters->InputParameters.OpenFile;
+    BOOLEAN Result;
+
+    if (!Parameters->ReturnValueValid) {
+        Result = CaptureOpenState( Process,
+                                   Parameters,
+                                   p->ObjectAttributes,
+                                   IsFileWriteAccessRequested( p->DesiredAccess, FILE_OPEN ),
+                                   p->FileHandle,
+                                   HANDLE_TYPE_FILE
+                                 );
+        if (Result
+            // && Parameters->SavedCallState.PathOpen.WriteAccessRequested
+           ) {
+            DbgEvent( CREATEEVENT, ( "NtOpenFile called:\n"
+                                     "    Name:   %ws\n"
+                                     "    Access: %s\n"
+                                     "    Share:  %s\n"
+                                     "    Options:%s\n",
+                                     Parameters->SavedCallState.FullName,
+                                     FormatEnumType( 0,
+                                                     FileAccessNames,
+                                                     p->DesiredAccess,
+                                                     TRUE
+                                                   ),
+                                     FormatEnumType( 1,
+                                                     FileShareNames,
+                                                     p->ShareAccess,
+                                                     TRUE
+                                                   ),
+                                     FormatEnumType( 2,
+                                                     FileCreateOptionNames,
+                                                     p->OpenOptions,
+                                                     TRUE
+                                                   )
+                                   )
+                    );
+            }
+        }
+    else {
+        Result = CompleteOpenState( Process,
+                                    Parameters
+                                  );
+        if (Result
+            // && Parameters->SavedCallState.PathOpen.WriteAccessRequested
+           ) {
+            IO_STATUS_BLOCK IoStatusBlock;
+
+            ReadMemory( Process,
+                        p->IoStatusBlock,
+                        &IoStatusBlock,
+                        sizeof( IoStatusBlock ),
+                        "IoStatusBlock"
+                      );
+            DbgEvent( CREATEEVENT, ( "*** Returned %s [%s %s]\n",
+                                     FormatEnumType( 0,
+                                                     (PENUM_TYPE_NAMES)ntstatusSymbolicNames,
+                                                     Parameters->ReturnValue.ReturnedLong,
+                                                     FALSE
+                                                   ),
+                                     FormatEnumType( 1,
+                                                     (PENUM_TYPE_NAMES)ntstatusSymbolicNames,
+                                                     IoStatusBlock.Status,
+                                                     FALSE
+                                                   ),
+                                     FormatEnumType( 2,
+                                                     FileIoStatusInfoNames,
+                                                     IoStatusBlock.Information,
+                                                     FALSE
+                                                   )
+                                   )
+                    );
+            }
+        }
+
+    return Result;
+}
+
+BOOLEAN
+NtDeleteFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PDELETEFILE_PARAMETERS p = &Parameters->InputParameters.DeleteFile;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    UNICODE_STRING ObjectName;
+    PWSTR FullName;
+    BOOLEAN Result, CallSuccessful;
+    PFILE_REFERENCE FileReference;
+
+    if (!Parameters->ReturnValueValid) {
+        if (CaptureObjectAttributes( Process,
+                                     p->ObjectAttributes,
+                                     &ObjectAttributes,
+                                     &ObjectName
+                                   ) &&
+            CaptureFullName( Process,
+                             HANDLE_TYPE_FILE,
+                             ObjectAttributes.RootDirectory,
+                             ObjectName.Buffer,
+                             ObjectName.Length,
+                             &FullName
+                           ) &&
+            CreateSavedCallState( Process,
+                                  &Parameters->SavedCallState,
+                                  DeletePath,
+                                  HANDLE_TYPE_FILE,
+                                  FullName
+                                )
+           ) {
+            Result = CreateFileReference( FullName,
+                                          TRUE,
+                                          (PFILE_REFERENCE *)&Parameters->SavedCallState.Reference
+                                        );
+            }
+        else {
+            Result = FALSE;
+            }
+
+        return Result;
+        }
+    else {
+        if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong )) {
+            CallSuccessful = TRUE;
+            }
+        else {
+            CallSuccessful = FALSE;
+            }
+
+        FileReference = (PFILE_REFERENCE)Parameters->SavedCallState.Reference;
+        CompleteFileReference( FileReference,
+                               CallSuccessful,
+                               TRUE,
+                               NULL
+                             );
+
+        return TRUE;
+        }
+}
+
+#undef DeleteFile
+
+
+BOOLEAN
+NtSetInformationFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PSETINFORMATIONFILE_PARAMETERS p = &Parameters->InputParameters.SetInformationFile;
+    POPENHANDLE_INFO HandleInfo;
+    FILE_RENAME_INFORMATION RenameInformation;
+    FILE_DISPOSITION_INFORMATION DispositionInformation;
+    PWSTR NewName, OldName;
+    PFILE_REFERENCE OldFileReference;
+    PFILE_REFERENCE NewFileReference;
+    BOOLEAN Result, CallSuccessful;
+
+    HandleInfo = FindOpenHandle( Process,
+                                 p->FileHandle,
+                                 HANDLE_TYPE_FILE
+                               );
+    if (HandleInfo == NULL) {
+        Result = FALSE;
+        }
+    else
+    if (p->FileInformationClass == FileRenameInformation) {
+        //
+        // Renaming an open file.
+        //
+        if (!Parameters->ReturnValueValid) {
+            if (ReadMemory( Process,
+                            p->FileInformation,
+                            &RenameInformation,
+                            FIELD_OFFSET( FILE_RENAME_INFORMATION, FileName ),
+                            "rename information"
+                          ) &&
+                CaptureFullName( Process,
+                                 HANDLE_TYPE_FILE,
+                                 RenameInformation.RootDirectory,
+                                 &((PFILE_RENAME_INFORMATION)(p->FileInformation))->FileName[ 0 ],
+                                 RenameInformation.FileNameLength,
+                                 &NewName
+                               ) &&
+                CreateSavedCallState( Process,
+                                      &Parameters->SavedCallState,
+                                      RenamePath,
+                                      HANDLE_TYPE_FILE,
+                                      HandleInfo->Name,
+                                      NewName,
+                                      RenameInformation.ReplaceIfExists
+                                    )
+               ) {
+                Result = CreateFileReference( NewName,
+                                              RenameInformation.ReplaceIfExists,
+                                              (PFILE_REFERENCE *)&Parameters->SavedCallState.Reference
+                                            );
+                }
+            else {
+                Result = FALSE;
+                }
+            }
+        else {
+            OldName = NULL;
+            if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong )) {
+                CallSuccessful = TRUE;
+                OldFileReference = FindFileReference( HandleInfo->Name );
+                if (OldFileReference) {
+                    OldName = OldFileReference->Name;
+                    }
+                }
+            else {
+                CallSuccessful = FALSE;
+                OldFileReference = NULL;
+                }
+
+            NewFileReference = (PFILE_REFERENCE)Parameters->SavedCallState.Reference;
+            NewName = NewFileReference->Name;
+            CompleteFileReference( NewFileReference,
+                                   CallSuccessful,
+                                   (BOOLEAN)(!NewFileReference->Created),
+                                   OldFileReference
+                                 );
+            Result = TRUE;
+            }
+        }
+    else
+    if (p->FileInformationClass == FileDispositionInformation) {
+        //
+        // Marking an open file for delete.
+        //
+        if (!Parameters->ReturnValueValid) {
+            if (ReadMemory( Process,
+                            p->FileInformation,
+                            &DispositionInformation,
+                            sizeof( DispositionInformation ),
+                            "disposition information"
+                          ) &&
+                DispositionInformation.DeleteFile &&
+                CreateSavedCallState( Process,
+                                      &Parameters->SavedCallState,
+                                      DeletePath,
+                                      HANDLE_TYPE_FILE,
+                                      HandleInfo->Name
+                                    )
+               ) {
+                Result = TRUE;
+                }
+            else {
+                Result = FALSE;
+                }
+            }
+        else {
+            if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong )) {
+                if (OldFileReference = FindFileReference( HandleInfo->Name )) {
+                    if (OldFileReference->Created) {
+                        LogEvent( INSTALER_EVENT_DELETE_TEMP_FILE,
+                                  2,
+                                  OldFileReference->DirectoryFile ? L"directory" : L"file",
+                                  OldFileReference->Name
+                                );
+                        DestroyFileReference( OldFileReference );
+                        }
+                    else {
+                        OldFileReference->Deleted = TRUE;
+                        LogEvent( INSTALER_EVENT_DELETE_FILE,
+                                  2,
+                                  OldFileReference->DirectoryFile ? L"directory" : L"file",
+                                  OldFileReference->Name
+                                );
+                        }
+                    }
+                }
+
+            Result = TRUE;
+            }
+        }
+    else {
+        Result = FALSE;
+        }
+
+    return Result;
+}
+
+
+
+
+BOOLEAN
+CaptureUnicodeString(
+    PPROCESS_INFO Process,
+    PUNICODE_STRING UnicodeStringAddress,
+    PWSTR *ReturnedString
+    )
+{
+    UNICODE_STRING UnicodeString;
+    PWSTR s;
+
+    s = NULL;
+    if (ReadMemory( Process,
+                    UnicodeStringAddress,
+                    &UnicodeString,
+                    sizeof( UnicodeString ),
+                    "unicode string"
+                  ) &&
+        ((s = AllocMem( UnicodeString.Length + sizeof( UNICODE_NULL ) )) != NULL) &&
+        ReadMemory( Process,
+                    UnicodeString.Buffer,
+                    s,
+                    UnicodeString.Length,
+                    "unicode string buffer"
+                  )
+       ) {
+        *ReturnedString = s;
+        return TRUE;
+        }
+
+    FreeMem( &s );
+    return FALSE;
+}
+
+
+BOOLEAN
+NtQueryAttributesFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PQUERYATTRIBUTESFILE_PARAMETERS p = &Parameters->InputParameters.QueryAttributesFile;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    UNICODE_STRING ObjectName;
+    PWSTR FullName;
+    NTSTATUS Status;
+    BOOLEAN Result;
+    CHAR Buffer[ MAX_PATH ];
+
+    if (!Parameters->ReturnValueValid) {
+        FullName = NULL;
+        Result = FALSE;
+        if (CaptureObjectAttributes( Process,
+                                     p->ObjectAttributes,
+                                     &ObjectAttributes,
+                                     &ObjectName
+                                   ) &&
+            CaptureFullName( Process,
+                             HANDLE_TYPE_FILE,
+                             ObjectAttributes.RootDirectory,
+                             ObjectName.Buffer,
+                             ObjectName.Length,
+                             &FullName
+                           ) &&
+            CreateSavedCallState( Process,
+                                  &Parameters->SavedCallState,
+                                  QueryPath,
+                                  HANDLE_TYPE_FILE,
+                                  FullName
+                                )
+           ) {
+            Result = CreateFileReference( FullName,
+                                          FALSE,
+                                          (PFILE_REFERENCE *)&Parameters->SavedCallState.Reference
+                                        );
+            }
+        else {
+            Result = FALSE;
+            }
+
+        return Result;
+        }
+    else {
+        FILE_BASIC_INFORMATION FileInformation;
+
+        ReadMemory( Process,
+                    p->FileInformation,
+                    &FileInformation,
+                    sizeof( FileInformation ),
+                    "FileInformation"
+                  );
+        return TRUE;
+        }
+}
+
+BOOLEAN
+NtQueryDirectoryFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PQUERYDIRECTORYFILE_PARAMETERS p = &Parameters->InputParameters.QueryDirectoryFile;
+    POPENHANDLE_INFO HandleInfo;
+    PWSTR FileName;
+    NTSTATUS Status;
+    BOOLEAN Result;
+    PULONG pNextEntryOffset;
+    ULONG NextEntryOffset;
+    ULONG EntriesReturned;
+
+    if (!Parameters->ReturnValueValid) {
+        FileName = NULL;
+        Result = FALSE;
+        if ((HandleInfo = FindOpenHandle( Process,
+                                          p->FileHandle,
+                                          HANDLE_TYPE_FILE
+                                        )
+            ) != NULL &&
+            p->FileName != NULL &&
+            CaptureUnicodeString( Process,
+                                  p->FileName,
+                                  &FileName
+                                )
+           ) {
+            if (HandleInfo->RootDirectory &&
+                !wcscmp( FileName, L"*" ) || !wcscmp( FileName, L"*.*" )
+               ) {
+                if (AskUserOnce) {
+                    AskUserOnce = FALSE;
+                    if (AskUser( MB_OKCANCEL,
+                                 INSTALER_ASKUSER_ROOTSCAN,
+                                 1,
+                                 HandleInfo->Name
+                               ) == IDCANCEL
+                       ) {
+                        FailAllScansOfRootDirectories = TRUE;
+                        }
+                    }
+
+                Parameters->AbortCall = FailAllScansOfRootDirectories;
+                }
+
+            if (FileName) {
+                HandleInfo->QueryName = FileName;
+                }
+            }
+
+        return TRUE;
+        }
+    else {
+        if (Parameters->AbortCall) {
+            //
+            // If we get here, then user wanted to fail this call.
+            //
+            Status = STATUS_NO_MORE_FILES;
+            SetProcedureReturnValue( Process,
+                                     Thread,
+                                     &Status,
+                                     sizeof( Status )
+                                   );
+            return TRUE;
+            }
+        else  {
+            if ((HandleInfo = FindOpenHandle( Process,
+                                              p->FileHandle,
+                                              HANDLE_TYPE_FILE
+                                            )
+                ) != NULL
+               ) {
+                //
+                // If successful, count entries returned
+                //
+                if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong )) {
+                    //
+                    // Return buffer is a set of records, the first DWORD of each contains
+                    // the offset to the next one or zero to indicate the end.  Count them.
+                    //
+                    pNextEntryOffset = (PULONG)p->FileInformation;
+                    EntriesReturned = 1;
+                    while (ReadMemory( Process,
+                                       pNextEntryOffset,
+                                       &NextEntryOffset,
+                                       sizeof( NextEntryOffset ),
+                                       "DirectoryInformation"
+                                     ) &&
+                           NextEntryOffset != 0
+                          ) {
+                        pNextEntryOffset = (PULONG)((PCHAR)pNextEntryOffset + NextEntryOffset);
+                        EntriesReturned += 1;
+                        }
+
+                    LogEvent( INSTALER_EVENT_SCAN_DIRECTORY,
+                              3,
+                              HandleInfo->Name,
+                              HandleInfo->QueryName ? HandleInfo->QueryName : L"*",
+                              EntriesReturned
+                            );
+
+                    }
+                else {
+                    FreeMem( &HandleInfo->QueryName );
+                    }
+                }
+            }
+
+        return TRUE;
+        }
+}
+
+
+BOOLEAN
+IsKeyWriteAccessRequested(
+    ACCESS_MASK DesiredAccess
+    )
+{
+    if (DesiredAccess & (GENERIC_WRITE |
+                         GENERIC_ALL |
+                         DELETE |
+                         KEY_SET_VALUE |
+                         KEY_CREATE_SUB_KEY |
+                         KEY_CREATE_LINK
+                        )
+       ) {
+        return TRUE;
+        }
+
+    return FALSE;
+}
+
+BOOLEAN
+NtCreateKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PCREATEKEY_PARAMETERS p = &Parameters->InputParameters.CreateKey;
+    BOOLEAN Result;
+
+    if (!Parameters->ReturnValueValid) {
+        Result = CaptureOpenState( Process,
+                                   Parameters,
+                                   p->ObjectAttributes,
+                                   IsKeyWriteAccessRequested( p->DesiredAccess ),
+                                   p->KeyHandle,
+                                   HANDLE_TYPE_KEY
+                                 );
+        }
+    else {
+        Result = CompleteOpenState( Process,
+                                    Parameters
+                                  );
+        }
+
+    return Result;
+}
+
+BOOLEAN
+NtOpenKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    POPENKEY_PARAMETERS p = &Parameters->InputParameters.OpenKey;
+    BOOLEAN Result;
+
+    if (!Parameters->ReturnValueValid) {
+        Result = CaptureOpenState( Process,
+                                   Parameters,
+                                   p->ObjectAttributes,
+                                   IsKeyWriteAccessRequested( p->DesiredAccess ),
+                                   p->KeyHandle,
+                                   HANDLE_TYPE_KEY
+                                 );
+        }
+    else {
+        Result = CompleteOpenState( Process,
+                                    Parameters
+                                  );
+        }
+
+    return Result;
+}
+
+BOOLEAN
+NtDeleteKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PDELETEKEY_PARAMETERS p = &Parameters->InputParameters.DeleteKey;
+    POPENHANDLE_INFO HandleInfo;
+    PKEY_REFERENCE OldKeyReference;
+    BOOLEAN Result;
+
+    //
+    // Marking an open key for delete.
+    //
+    HandleInfo = FindOpenHandle( Process,
+                                 p->KeyHandle,
+                                 HANDLE_TYPE_KEY
+                               );
+    if (HandleInfo == NULL) {
+        Result = FALSE;
+        }
+    else
+    if (!Parameters->ReturnValueValid) {
+        if (CreateSavedCallState( Process,
+                                  &Parameters->SavedCallState,
+                                  DeletePath,
+                                  HANDLE_TYPE_KEY,
+                                  HandleInfo->Name
+                                )
+           ) {
+            Result = TRUE;
+            }
+        else {
+            Result = FALSE;
+            }
+        }
+    else {
+        if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong )) {
+            if (OldKeyReference = FindKeyReference( HandleInfo->Name )) {
+                if (OldKeyReference->Created) {
+                    LogEvent( INSTALER_EVENT_DELETE_TEMP_KEY,
+                              1,
+                              OldKeyReference->Name
+                            );
+                    DestroyKeyReference( OldKeyReference );
+                    }
+                else {
+                    MarkKeyDeleted( OldKeyReference );
+                    LogEvent( INSTALER_EVENT_DELETE_KEY,
+                              1,
+                              OldKeyReference->Name
+                            );
+                    }
+                }
+            }
+
+        Result = TRUE;
+        }
+
+    return Result;
+}
+
+BOOLEAN
+CaptureValueName(
+    PPROCESS_INFO Process,
+    PUNICODE_STRING Name,
+    PWSTR *ReturnedValueName
+    )
+{
+    UNICODE_STRING ValueName;
+    PWSTR s;
+
+    *ReturnedValueName = NULL;
+    if (Name == NULL ||
+        !ReadMemory( Process,
+                     Name,
+                     &ValueName,
+                     sizeof( ValueName ),
+                     "value name string"
+                   )
+       ) {
+        return FALSE;
+        }
+
+    s = AllocMem( ValueName.Length + sizeof( UNICODE_NULL ) );
+    if (s == NULL) {
+        return FALSE;
+        }
+
+    if (!ReadMemory( Process,
+                     ValueName.Buffer,
+                     s,
+                     ValueName.Length,
+                     "value name buffer"
+                   )
+       ) {
+        FreeMem( &s );
+        return FALSE;
+        }
+
+    s[ ValueName.Length / sizeof( WCHAR ) ] = UNICODE_NULL;
+    ValueName.Buffer = s;
+    ValueName.MaximumLength = (USHORT)(ValueName.Length + sizeof( UNICODE_NULL ));
+    *ReturnedValueName = AddName( &ValueName );
+    FreeMem( &ValueName.Buffer );
+    return TRUE;
+}
+
+
+BOOLEAN
+NtSetValueKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PSETVALUEKEY_PARAMETERS p = &Parameters->InputParameters.SetValueKey;
+    POPENHANDLE_INFO HandleInfo;
+    PWSTR ValueName;
+    PKEY_REFERENCE KeyReference;
+    PVALUE_REFERENCE ValueReference;
+    BOOLEAN Result;
+
+    //
+    // Setting a value
+    //
+    HandleInfo = FindOpenHandle( Process,
+                                 p->KeyHandle,
+                                 HANDLE_TYPE_KEY
+                               );
+    if (HandleInfo == NULL) {
+        Result = FALSE;
+        }
+    else
+    if (!Parameters->ReturnValueValid) {
+        if (CaptureValueName( Process,
+                              p->ValueName,
+                              &ValueName
+                            ) &&
+            CreateSavedCallState( Process,
+                                  &Parameters->SavedCallState,
+                                  SetValue,
+                                  HANDLE_TYPE_KEY,
+                                  ValueName
+                                )
+           ) {
+            Result = TRUE;
+            }
+        else {
+            Result = FALSE;
+            }
+        }
+    else {
+        if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong ) &&
+            (KeyReference = FindKeyReference( HandleInfo->Name ))
+           ) {
+            CreateValueReference( Process,
+                                  KeyReference,
+                                  Parameters->SavedCallState.FullName,
+                                  p->TitleIndex,
+                                  p->Type,
+                                  p->Data,
+                                  p->DataLength,
+                                  &ValueReference
+                                );
+
+            if (ValueReference != NULL) {
+                LogEvent( INSTALER_EVENT_SET_KEY_VALUE,
+                          2,
+                          ValueReference->Name,
+                          KeyReference->Name
+                        );
+                }
+            }
+
+        Result = TRUE;
+        }
+
+    return Result;
+}
+
+BOOLEAN
+NtDeleteValueKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PDELETEVALUEKEY_PARAMETERS p = &Parameters->InputParameters.DeleteValueKey;
+    POPENHANDLE_INFO HandleInfo;
+    PWSTR ValueName;
+    PKEY_REFERENCE KeyReference;
+    PVALUE_REFERENCE ValueReference;
+    BOOLEAN Result;
+
+    //
+    // Marking a value for delete.
+    //
+    HandleInfo = FindOpenHandle( Process,
+                                 p->KeyHandle,
+                                 HANDLE_TYPE_KEY
+                               );
+    if (HandleInfo == NULL) {
+        Result = FALSE;
+        }
+    else
+    if (!Parameters->ReturnValueValid) {
+        if (CaptureValueName( Process,
+                              p->ValueName,
+                              &ValueName
+                            ) &&
+            CreateSavedCallState( Process,
+                                  &Parameters->SavedCallState,
+                                  DeleteValue,
+                                  HANDLE_TYPE_KEY,
+                                  ValueName
+                                )
+           ) {
+            Result = TRUE;
+            }
+        else {
+            Result = FALSE;
+            }
+        }
+    else {
+        if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong ) &&
+            (KeyReference = FindKeyReference( HandleInfo->Name )) &&
+            (ValueReference = FindValueReference( KeyReference, Parameters->SavedCallState.FullName ))
+           ) {
+            if (ValueReference->Created) {
+                LogEvent( INSTALER_EVENT_DELETE_KEY_TEMP_VALUE,
+                          2,
+                          ValueReference->Name,
+                          KeyReference->Name
+                        );
+                DestroyValueReference( ValueReference );
+                }
+            else {
+                ValueReference->Deleted = TRUE;
+                LogEvent( INSTALER_EVENT_DELETE_KEY_VALUE,
+                          2,
+                          ValueReference->Name,
+                          KeyReference->Name
+                        );
+                }
+            }
+
+        Result = TRUE;
+        }
+
+    return Result;
+}
+
+
+BOOLEAN
+NtCloseHandleHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PCLOSEHANDLE_PARAMETERS p = &Parameters->InputParameters.CloseHandle;
+    POPENHANDLE_INFO HandleInfo;
+    PFILE_REFERENCE FileReference;
+
+    HandleInfo = FindOpenHandle( Process, p->Handle, (ULONG)-1 );
+    if (!Parameters->ReturnValueValid) {
+        if (HandleInfo != NULL) {
+            return TRUE;
+            }
+        else {
+            return FALSE;
+            }
+        }
+    else {
+        if (NT_SUCCESS( Parameters->ReturnValue.ReturnedLong )) {
+            if (HandleInfo != NULL &&
+                HandleInfo->Type == HANDLE_TYPE_FILE &&
+                (FileReference = FindFileReference( HandleInfo->Name )) != NULL &&
+                FileReference->WriteAccess &&
+                !FileReference->Created &&
+                !FileReference->DirectoryFile &&
+                IsNewFileSameAsBackup( FileReference )
+               ) {
+                DestroyFileReference( FileReference );
+                FileReference = NULL;
+                }
+
+            DeleteOpenHandle( Process, p->Handle, (ULONG)-1 );
+            }
+
+        return TRUE;
+        }
+}
+
+UCHAR AnsiStringBuffer[ MAX_PATH+1 ];
+WCHAR UnicodeStringBuffer[ MAX_PATH+1 ];
+
+BOOLEAN
+CaptureAnsiAsUnicode(
+    PPROCESS_INFO Process,
+    LPCSTR Address,
+    BOOLEAN DoubleNullTermination,
+    PWSTR *ReturnedName,
+    PWSTR *ReturnedData
+    )
+{
+    NTSTATUS Status;
+    ULONG BytesRead;
+    ANSI_STRING AnsiString;
+    UNICODE_STRING UnicodeString;
+
+    if (Address == NULL) {
+        if (ReturnedName != NULL) {
+            *ReturnedName = NULL;
+            }
+        else {
+            *ReturnedData = NULL;
+            }
+        return TRUE;
+        }
+
+    BytesRead = FillTemporaryBuffer( Process,
+                                     (PVOID)Address,
+                                     FALSE,
+                                     DoubleNullTermination
+                                   );
+    if (BytesRead != 0 && BytesRead < 0x7FFF) {
+        AnsiString.Buffer = TemporaryBuffer;
+        AnsiString.Length = (USHORT)BytesRead;
+        AnsiString.MaximumLength = (USHORT)BytesRead;
+        Status = RtlAnsiStringToUnicodeString( &UnicodeString, &AnsiString, TRUE );
+        if (NT_SUCCESS( Status )) {
+            if (ReturnedName != NULL) {
+                *ReturnedName = AddName( &UnicodeString );
+                RtlFreeUnicodeString( &UnicodeString );
+                return TRUE;
+                }
+            else {
+                *ReturnedData = UnicodeString.Buffer;
+                return TRUE;
+                }
+            }
+        }
+
+    return FALSE;
+}
+
+
+BOOLEAN
+CaptureUnicode(
+    PPROCESS_INFO Process,
+    LPCWSTR Address,
+    BOOLEAN DoubleNullTermination,
+    PWSTR *ReturnedName,
+    PWSTR *ReturnedData
+    )
+{
+    ULONG BytesRead;
+    UNICODE_STRING UnicodeString;
+
+    if (Address == NULL) {
+        if (ReturnedName != NULL) {
+            *ReturnedName = NULL;
+            }
+        else {
+            *ReturnedData = NULL;
+            }
+        return TRUE;
+        }
+
+    BytesRead = FillTemporaryBuffer( Process,
+                                     (PVOID)Address,
+                                     TRUE,
+                                     DoubleNullTermination
+                                   );
+    if (BytesRead != 0 && (BytesRead & 1) == 0 && BytesRead <= 0xFFFC) {
+        if (ReturnedName != NULL) {
+            RtlInitUnicodeString( &UnicodeString, TemporaryBuffer );
+            *ReturnedName = AddName( &UnicodeString );
+            return TRUE;
+            }
+        else {
+            *ReturnedData = AllocMem( BytesRead + sizeof( UNICODE_NULL ) );
+            if (*ReturnedData != NULL) {
+                memmove( *ReturnedData, TemporaryBuffer, BytesRead );
+                return TRUE;
+                }
+            }
+        }
+
+    return FALSE;
+}
+
+
+BOOLEAN
+GetVersionHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    DWORD dwVersion;
+
+    if (!Parameters->ReturnValueValid) {
+        if (AskUserOnce) {
+            AskUserOnce = FALSE;
+            if (AskUser( MB_OKCANCEL,
+                         INSTALER_ASKUSER_GETVERSION,
+                         0
+                       ) == IDCANCEL
+               ) {
+                DefaultGetVersionToWin95 = TRUE;
+                }
+            else {
+                DefaultGetVersionToWin95 = FALSE;
+                }
+            }
+
+        LogEvent( INSTALER_EVENT_GETVERSION,
+                  1,
+                  DefaultGetVersionToWin95 ? L"Windows 95" : L"Windows NT"
+                );
+        Parameters->AbortCall = DefaultGetVersionToWin95;
+        return Parameters->AbortCall;
+        }
+    else {
+        dwVersion = 0xC0000004;     // What Windows 95 returns
+        SetProcedureReturnValue( Process,
+                                 Thread,
+                                 &dwVersion,
+                                 sizeof( dwVersion )
+                               );
+        return TRUE;
+        }
+}
+
+BOOLEAN
+GetVersionExWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PGETVERSIONEXW_PARAMETERS p = &Parameters->InputParameters.GetVersionExW;
+    OSVERSIONINFOW VersionInformation;
+
+    if (!Parameters->ReturnValueValid) {
+        if (AskUserOnce) {
+            AskUserOnce = FALSE;
+            if (AskUser( MB_OKCANCEL,
+                         INSTALER_ASKUSER_GETVERSION,
+                         0
+                       ) == IDCANCEL
+               ) {
+                DefaultGetVersionToWin95 = TRUE;
+                }
+            else {
+                DefaultGetVersionToWin95 = FALSE;
+                }
+            }
+
+        Parameters->AbortCall = DefaultGetVersionToWin95;
+        return Parameters->AbortCall;
+        }
+    else {
+        memset( &VersionInformation, 0, sizeof( VersionInformation ) );
+        VersionInformation.dwMajorVersion = 4;
+        VersionInformation.dwBuildNumber  = 0x3B6;  // What Windows 95 returns
+        VersionInformation.dwPlatformId = VER_PLATFORM_WIN32_WINDOWS;
+        WriteMemory( Process,
+                     p->lpVersionInformation,
+                     &VersionInformation,
+                     sizeof( VersionInformation ),
+                     "GetVersionExW"
+                   );
+
+        return TRUE;
+        }
+}
+
+BOOLEAN
+SetCurrentDirectoryAHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PSETCURRENTDIRECTORYA_PARAMETERS p = &Parameters->InputParameters.SetCurrentDirectoryA;
+    PWSTR PathName;
+    WCHAR PathBuffer[ MAX_PATH ];
+
+    if (!Parameters->ReturnValueValid) {
+        if (CaptureAnsiAsUnicode( Process, p->lpPathName, FALSE, NULL, &PathName )) {
+            Parameters->CurrentDirectory = AllocMem( (wcslen( PathName ) + 1) * sizeof( WCHAR ) );
+            if (Parameters->CurrentDirectory != NULL) {
+                wcscpy( Parameters->CurrentDirectory, PathName );
+                return TRUE;
+                }
+            }
+
+        return FALSE;
+        }
+    else {
+        if (Parameters->ReturnValue.ReturnedBool != 0) {
+            if (SetCurrentDirectory( Parameters->CurrentDirectory ) &&
+                GetCurrentDirectory( MAX_PATH, PathBuffer )
+               ) {
+                LogEvent( INSTALER_EVENT_SET_DIRECTORY,
+                          1,
+                          PathBuffer
+                        );
+                }
+            }
+
+        FreeMem( &Parameters->CurrentDirectory );
+        return TRUE;
+        }
+}
+
+BOOLEAN
+SetCurrentDirectoryWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PSETCURRENTDIRECTORYW_PARAMETERS p = &Parameters->InputParameters.SetCurrentDirectoryW;
+    PWSTR PathName;
+    WCHAR PathBuffer[ MAX_PATH ];
+
+    if (!Parameters->ReturnValueValid) {
+        if (CaptureUnicode( Process, p->lpPathName, FALSE, NULL, &PathName )) {
+            Parameters->CurrentDirectory = AllocMem( (wcslen( PathName ) + 1) * sizeof( WCHAR ) );
+            if (Parameters->CurrentDirectory != NULL) {
+                wcscpy( Parameters->CurrentDirectory, PathName );
+                return TRUE;
+                }
+            }
+
+        return FALSE;
+        }
+    else {
+        if (Parameters->ReturnValue.ReturnedBool != 0) {
+            if (SetCurrentDirectory( Parameters->CurrentDirectory ) &&
+                GetCurrentDirectory( MAX_PATH, PathBuffer )
+               ) {
+                LogEvent( INSTALER_EVENT_SET_DIRECTORY,
+                          1,
+                          PathBuffer
+                        );
+                }
+            }
+
+        FreeMem( &Parameters->CurrentDirectory );
+        return TRUE;
+        }
+}
+
+BOOLEAN
+GetIniFilePath(
+    PWSTR IniFileName,
+    PWSTR *ReturnedIniFilePath
+    )
+{
+    NTSTATUS Status;
+    UNICODE_STRING FileName, UnicodeString;
+    PWSTR FilePart;
+    DWORD n;
+
+    if (IniFileName == NULL) {
+        RtlInitUnicodeString( &FileName, L"win.ini" );
+        }
+    else {
+        RtlInitUnicodeString( &FileName, IniFileName );
+        }
+
+    if ((FileName.Length > sizeof( WCHAR ) &&
+         FileName.Buffer[ 1 ] == L':'
+        ) ||
+        (FileName.Length != 0 &&
+         wcscspn( FileName.Buffer, L"\\/" ) != (FileName.Length / sizeof( WCHAR ))
+        )
+       ) {
+        UnicodeString.MaximumLength = (USHORT)(MAX_PATH * sizeof( WCHAR  ));
+        UnicodeString.Buffer = AllocMem( UnicodeString.MaximumLength );
+        if (UnicodeString.Buffer == NULL) {
+            Status = STATUS_NO_MEMORY;
+            }
+        else {
+            UnicodeString.Length = 0;
+            n = GetFullPathNameW( FileName.Buffer,
+                                  UnicodeString.MaximumLength / sizeof( WCHAR ),
+                                  UnicodeString.Buffer,
+                                  &FilePart
+                                );
+            if (n > UnicodeString.MaximumLength) {
+                Status = STATUS_BUFFER_TOO_SMALL;
+                }
+            else {
+                UnicodeString.Length = (USHORT)(n * sizeof( WCHAR ));
+                Status = STATUS_SUCCESS;
+                }
+            }
+        }
+    else {
+        UnicodeString.Length = 0;
+        UnicodeString.MaximumLength = (USHORT)(WindowsDirectory.Length +
+                                               sizeof( WCHAR  ) +
+                                               FileName.Length +
+                                               sizeof( UNICODE_NULL )
+                                              );
+        UnicodeString.Buffer = AllocMem( UnicodeString.MaximumLength );
+        if (UnicodeString.Buffer == NULL) {
+            Status = STATUS_NO_MEMORY;
+            }
+        else {
+            RtlCopyUnicodeString( &UnicodeString, &WindowsDirectory );
+            Status = RtlAppendUnicodeToString( &UnicodeString,
+                                               L"\\"
+                                             );
+            if (NT_SUCCESS( Status )) {
+                Status = RtlAppendUnicodeStringToString( &UnicodeString,
+                                                         &FileName
+                                                       );
+                }
+            }
+        }
+
+    if (IniFileName != NULL) {
+        FreeMem( &IniFileName );
+        }
+
+    if (NT_SUCCESS( Status )) {
+        *ReturnedIniFilePath = AddName( &UnicodeString );
+        FreeMem( &UnicodeString.Buffer );
+        return TRUE;
+        }
+    else {
+        FreeMem( &UnicodeString.Buffer );
+        return FALSE;
+        }
+}
+
+BOOLEAN
+WritePrivateProfileStringEntry(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters,
+    PWSTR IniFilePath,
+    PWSTR SectionName,
+    PWSTR VariableName,
+    PWSTR VariableValue
+    )
+{
+    if (CreateSavedCallState( Process,
+                              &Parameters->SavedCallState,
+                              WriteIniValue,
+                              HANDLE_TYPE_NONE,
+                              IniFilePath,
+                              SectionName,
+                              VariableName,
+                              VariableValue
+                            ) &&
+        CreateIniFileReference( IniFilePath,
+                                (PINI_FILE_REFERENCE *)&Parameters->SavedCallState.Reference
+                              )
+       ) {
+        return TRUE;
+        }
+    else {
+        FreeMem( &VariableValue );
+        return FALSE;
+        }
+}
+
+
+BOOLEAN
+WritePrivateProfileStringExit(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PAPI_SAVED_CALL_STATE CallState;
+    PINI_FILE_REFERENCE IniFileReference;
+    PINI_SECTION_REFERENCE IniSectionReference;
+    PINI_VARIABLE_REFERENCE IniVariableReference;
+
+    if (Parameters->ReturnValue.ReturnedLong != 0) {
+        CallState = &Parameters->SavedCallState;
+        if (CallState->FullName == NULL &&
+            CallState->SetIniValue.SectionName == NULL &&
+            CallState->SetIniValue.VariableName == NULL
+           ) {
+            //
+            // Ignore calls to flush INI cache
+            //
+
+            return FALSE;
+            }
+
+        IniFileReference = FindIniFileReference( CallState->FullName );
+        IniSectionReference = FindIniSectionReference( IniFileReference,
+                                                       CallState->SetIniValue.SectionName,
+                                                       (BOOLEAN)(CallState->SetIniValue.VariableName != NULL)
+                                                     );
+        if (IniSectionReference != NULL) {
+            if (CallState->SetIniValue.VariableName == NULL) {
+                IniSectionReference->Deleted = TRUE;
+                LogEvent( INSTALER_EVENT_INI_DELETE_SECTION,
+                          2,
+                          CallState->FullName,
+                          CallState->SetIniValue.SectionName
+                        );
+                }
+            else {
+                IniVariableReference = FindIniVariableReference( IniSectionReference,
+                                                                 CallState->SetIniValue.VariableName,
+                                                                 (BOOLEAN)(CallState->SetIniValue.VariableValue != NULL)
+                                                               );
+                if (IniVariableReference != NULL) {
+                    if (CallState->SetIniValue.VariableValue != NULL) {
+                        FreeMem( &IniVariableReference->Value );
+                        IniVariableReference->Value = CallState->SetIniValue.VariableValue;
+                        CallState->SetIniValue.VariableValue = NULL;
+                        if (!IniVariableReference->Created) {
+                            if (!wcscmp( IniVariableReference->Value,
+                                         IniVariableReference->OriginalValue
+                                       )
+                               ) {
+                                FreeMem( &IniVariableReference->Value );
+                                }
+                            else {
+                                IniVariableReference->Modified = TRUE;
+                                LogEvent( INSTALER_EVENT_INI_CHANGE,
+                                          5,
+                                          CallState->FullName,
+                                          CallState->SetIniValue.SectionName,
+                                          CallState->SetIniValue.VariableName,
+                                          IniVariableReference->Value,
+                                          IniVariableReference->OriginalValue
+                                        );
+                                }
+                            }
+                        else {
+                            LogEvent( INSTALER_EVENT_INI_CREATE,
+                                      4,
+                                      CallState->FullName,
+                                      CallState->SetIniValue.SectionName,
+                                      CallState->SetIniValue.VariableName,
+                                      IniVariableReference->Value
+                                    );
+                            }
+                        }
+                    else
+                    if (!IniVariableReference->Created) {
+                        IniVariableReference->Deleted = TRUE;
+                        LogEvent( INSTALER_EVENT_INI_DELETE,
+                                  4,
+                                  CallState->FullName,
+                                  CallState->SetIniValue.SectionName,
+                                  CallState->SetIniValue.VariableName,
+                                  IniVariableReference->OriginalValue
+                                );
+                        }
+                    else {
+                        DestroyIniVariableReference( IniVariableReference );
+                        }
+                    }
+                }
+            }
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+WritePrivateProfileStringAHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PWRITEPRIVATEPROFILESTRINGA_PARAMETERS p = &Parameters->InputParameters.WritePrivateProfileStringA;
+    PWSTR SectionName, VariableName, FileName, VariableValue;
+    PWSTR IniFilePath;
+
+    if (!Parameters->ReturnValueValid) {
+        FileName = NULL;
+        VariableValue = NULL;
+        if (CaptureAnsiAsUnicode( Process, p->lpFileName, FALSE, NULL, &FileName ) &&
+            GetIniFilePath( FileName, &IniFilePath ) &&
+            CaptureAnsiAsUnicode( Process, p->lpAppName, FALSE, &SectionName, NULL ) &&
+            CaptureAnsiAsUnicode( Process, p->lpKeyName, FALSE, &VariableName, NULL ) &&
+            CaptureAnsiAsUnicode( Process, p->lpString, FALSE, NULL, &VariableValue )
+           ) {
+            if (FileName != NULL || SectionName != NULL) {
+                return WritePrivateProfileStringEntry( Process,
+                                                       Thread,
+                                                       Parameters,
+                                                       IniFilePath,
+                                                       SectionName,
+                                                       VariableName,
+                                                       VariableValue
+                                                     );
+                }
+            }
+
+        return TRUE;
+        }
+    else {
+        return WritePrivateProfileStringExit( Process,
+                                              Thread,
+                                              Parameters
+                                            );
+        }
+}
+
+BOOLEAN
+WritePrivateProfileStringWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PWRITEPRIVATEPROFILESTRINGW_PARAMETERS p = &Parameters->InputParameters.WritePrivateProfileStringW;
+    PWSTR SectionName, VariableName, FileName, VariableValue;
+    PWSTR IniFilePath;
+
+    if (!Parameters->ReturnValueValid) {
+        FileName = NULL;
+        IniFilePath = NULL;
+        SectionName = NULL;
+        VariableName = NULL;
+        VariableValue = NULL;
+        if (CaptureUnicode( Process, p->lpFileName, FALSE, NULL, &FileName ) &&
+            GetIniFilePath( FileName, &IniFilePath ) &&
+            CaptureUnicode( Process, p->lpAppName, FALSE, &SectionName, NULL ) &&
+            CaptureUnicode( Process, p->lpKeyName, FALSE, &VariableName, NULL ) &&
+            CaptureUnicode( Process, p->lpString, FALSE, NULL, &VariableValue )
+           ) {
+            if (FileName != NULL || SectionName != NULL) {
+                return WritePrivateProfileStringEntry( Process,
+                                                       Thread,
+                                                       Parameters,
+                                                       IniFilePath,
+                                                       SectionName,
+                                                       VariableName,
+                                                       VariableValue
+                                                     );
+                }
+            }
+
+        return TRUE;
+        }
+    else {
+        return WritePrivateProfileStringExit( Process,
+                                              Thread,
+                                              Parameters
+                                            );
+        }
+}
+
+
+BOOLEAN
+WritePrivateProfileSectionEntry(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters,
+    PWSTR IniFilePath,
+    PWSTR SectionName,
+    PWSTR SectionValue
+    )
+{
+    if (CreateSavedCallState( Process,
+                              &Parameters->SavedCallState,
+                              WriteIniSection,
+                              HANDLE_TYPE_NONE,
+                              IniFilePath,
+                              SectionName,
+                              SectionValue
+                            ) &&
+        CreateIniFileReference( IniFilePath,
+                                (PINI_FILE_REFERENCE *)&Parameters->SavedCallState.Reference
+                              )
+       ) {
+        return TRUE;
+        }
+    else {
+        FreeMem( &SectionValue );
+        return FALSE;
+        }
+}
+
+
+BOOLEAN
+WritePrivateProfileSectionExit(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PAPI_SAVED_CALL_STATE CallState;
+    PINI_FILE_REFERENCE IniFileReference;
+    PINI_SECTION_REFERENCE IniSectionReference;
+    PINI_VARIABLE_REFERENCE IniVariableReference;
+    PWSTR VariableName, VariableValue;
+    UNICODE_STRING UnicodeString;
+
+    if (Parameters->ReturnValue.ReturnedLong != 0) {
+        CallState = &Parameters->SavedCallState;
+        IniFileReference = FindIniFileReference( CallState->FullName );
+        IniSectionReference = FindIniSectionReference( IniFileReference,
+                                                       CallState->SetIniSection.SectionName,
+                                                       (BOOLEAN)(CallState->SetIniSection.SectionValue != NULL)
+                                                     );
+        if (IniSectionReference != NULL) {
+            if (CallState->SetIniSection.SectionValue == NULL) {
+                IniSectionReference->Deleted = TRUE;
+                }
+            else {
+                VariableName = CallState->SetIniSection.SectionValue;
+                while (*VariableName) {
+                    VariableValue = VariableName;
+                    while (*VariableValue != UNICODE_NULL && *VariableValue != L'=') {
+                        VariableValue += 1;
+                        }
+
+                    if (*VariableValue != L'=') {
+                        break;
+                        }
+
+                    *VariableValue++ = UNICODE_NULL;
+
+                    RtlInitUnicodeString( &UnicodeString, VariableName );
+                    IniVariableReference = FindIniVariableReference( IniSectionReference,
+                                                                     AddName( &UnicodeString ),
+                                                                     (BOOLEAN)(*VariableValue != UNICODE_NULL)
+                                                                   );
+                    if (IniVariableReference != NULL) {
+                        if (*VariableValue != UNICODE_NULL) {
+                            FreeMem( &IniVariableReference->Value );
+                            IniVariableReference->Value = AllocMem( (wcslen( VariableValue ) + 1) * sizeof( WCHAR ) );
+                            wcscpy( IniVariableReference->Value, VariableValue );
+                            if (!IniVariableReference->Created) {
+                                if (!wcscmp( IniVariableReference->Value,
+                                             IniVariableReference->OriginalValue
+                                           )
+                                   ) {
+                                    FreeMem( &IniVariableReference->Value );
+                                    }
+                                else {
+                                    IniVariableReference->Modified = TRUE;
+                                    }
+                                }
+                            }
+                        else
+                        if (!IniVariableReference->Created) {
+                            IniVariableReference->Deleted = TRUE;
+                            }
+                        else {
+                            DestroyIniVariableReference( IniVariableReference );
+                            }
+                        }
+
+                    VariableName = VariableValue;
+                    while (*VariableName++ != UNICODE_NULL) {
+                        }
+                    }
+                }
+            }
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+WritePrivateProfileSectionAHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PWRITEPRIVATEPROFILESECTIONA_PARAMETERS p = &Parameters->InputParameters.WritePrivateProfileSectionA;
+    PWSTR SectionName, FileName, SectionValue;
+    PWSTR IniFilePath;
+
+    if (!Parameters->ReturnValueValid) {
+        FileName = NULL;
+        SectionValue = NULL;
+        if (CaptureAnsiAsUnicode( Process, p->lpFileName, FALSE, NULL, &FileName ) &&
+            GetIniFilePath( FileName, &IniFilePath ) &&
+            CaptureAnsiAsUnicode( Process, p->lpAppName, FALSE, &SectionName, NULL ) &&
+            CaptureAnsiAsUnicode( Process, p->lpString, TRUE, NULL, &SectionValue )
+           ) {
+            return WritePrivateProfileSectionEntry( Process,
+                                                    Thread,
+                                                    Parameters,
+                                                    IniFilePath,
+                                                    SectionName,
+                                                    SectionValue
+                                                  );
+            }
+        }
+    else {
+        return WritePrivateProfileSectionExit( Process,
+                                               Thread,
+                                               Parameters
+                                             );
+        }
+}
+
+BOOLEAN
+WritePrivateProfileSectionWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PWRITEPRIVATEPROFILESECTIONW_PARAMETERS p = &Parameters->InputParameters.WritePrivateProfileSectionW;
+    PWSTR SectionName, FileName, SectionValue;
+    PWSTR IniFilePath;
+
+    if (!Parameters->ReturnValueValid) {
+        FileName = NULL;
+        SectionValue = NULL;
+        if (CaptureUnicode( Process, p->lpFileName, FALSE, NULL, &FileName ) &&
+            GetIniFilePath( FileName, &IniFilePath ) &&
+            CaptureUnicode( Process, p->lpAppName, FALSE, &SectionName, NULL ) &&
+            CaptureUnicode( Process, p->lpString, TRUE, NULL, &SectionValue )
+           ) {
+            return WritePrivateProfileSectionEntry( Process,
+                                                    Thread,
+                                                    Parameters,
+                                                    IniFilePath,
+                                                    SectionName,
+                                                    SectionValue
+                                                  );
+            }
+        }
+    else {
+        return WritePrivateProfileSectionExit( Process,
+                                               Thread,
+                                               Parameters
+                                             );
+        }
+}
+
+
+BOOLEAN
+RegConnectRegistryWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    )
+{
+    PREGCONNECTREGISTRYW_PARAMETERS p = &Parameters->InputParameters.RegConnectRegistryW;
+    PWSTR MachineName;
+    LONG ErrorCode;
+    HKEY hKey;
+
+    if (!Parameters->ReturnValueValid) {
+        MachineName = NULL;
+        if (!CaptureUnicode( Process, p->lpMachineName, FALSE, NULL, &MachineName )) {
+            MachineName = L"Unknown";
+            }
+
+        if (AskUser( MB_OKCANCEL,
+                     INSTALER_ASKUSER_REGCONNECT,
+                     1,
+                     MachineName
+                   ) == IDCANCEL
+           ) {
+            FreeMem( &MachineName );
+            Parameters->AbortCall = TRUE;
+            return TRUE;
+            }
+        else {
+            FreeMem( &MachineName );
+            return FALSE;
+            }
+        }
+    else
+    if (Parameters->ReturnValue.ReturnedLong == 0) {
+        ErrorCode = ERROR_ACCESS_DENIED;
+        if (SetProcedureReturnValue( Process,
+                                     Thread,
+                                     &ErrorCode,
+                                     sizeof( ErrorCode )
+                                   )
+           ) {
+            if (ReadMemory( Process,
+                            p->phkResult,
+                            &hKey,
+                            sizeof( hKey ),
+                            "phkResult"
+                          )
+               ) {
+                RegCloseKey( hKey );
+                hKey = NULL;
+                WriteMemory( Process,
+                             p->phkResult,
+                             &hKey,
+                             sizeof( hKey ),
+                             "phkResult"
+                           );
+                }
+            }
+        }
+
+    return TRUE;
+}
diff --git a/private/sdktools/instaler/hlist.c b/private/sdktools/instaler/hlist.c
new file mode 100644
index 000000000..03172b5e2
--- /dev/null
+++ b/private/sdktools/instaler/hlist.c
@@ -0,0 +1,484 @@
+#include <windows.h>
+#include <custcntl.h>
+#include <commdlg.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include "hlist.h"
+
+
+typedef DWORD (CALLBACK* HLISTCALLBACK)(LPDWORD,LPSTR*,LPSTR,DWORD,DWORD);
+
+#define XBITMAP              16
+#define YBITMAP              16
+#define MARGIN               6
+#define INDENT               (XBITMAP + MARGIN)
+#define MIDDLE               ((XBITMAP/2) + MARGIN)
+#define LINE_COLOR           RGB(255,0,0)
+
+#define CLASS_NAME           "HList"
+#define DESCRIPTION          "Heir List Box"
+
+#define DEFAULT_STYLE        WS_CHILD               |   \
+                             WS_VISIBLE             |   \
+                             WS_VSCROLL             |   \
+                             WS_HSCROLL             |   \
+                             WS_BORDER              |   \
+                             LBS_NOTIFY             |   \
+                             LBS_NOINTEGRALHEIGHT   |   \
+                             LBS_WANTKEYBOARDINPUT  |   \
+                             LBS_SORT               |   \
+                             LBS_OWNERDRAWFIXED
+
+
+
+typedef struct _HLISTTYPE {
+    struct _HLISTTYPE   *next;
+    DWORD               type;
+    HBITMAP             bitmap;
+} HLISTTYPE, *LPHLISTTYPE;
+
+typedef struct _HLISTINFO {
+    HWND          hwndList;
+    LPHLISTTYPE   typeList;
+    HLISTCALLBACK lpCallback;
+} HLISTINFO, *LPHLISTINFO;
+
+typedef struct _ITEMDATA {
+    struct _ITEMDATA    *parent;
+    DWORD               type;
+    DWORD               level;
+    DWORD               nchild;
+    DWORD               childnum;
+    LPSTR               str;
+    HBITMAP             bitmap;
+} ITEMDATA, *LPITEMDATA;
+
+
+static HMODULE hInstance;
+
+
+LRESULT        HListWndProc(HWND,UINT,WPARAM,LPARAM);
+
+
+BOOL
+HListInitialize(
+    HMODULE hModule
+    )
+{
+    WNDCLASS       wndclass;
+
+
+    hInstance = hModule;
+
+    wndclass.style          = CS_HREDRAW | CS_VREDRAW | CS_GLOBALCLASS;
+    wndclass.lpfnWndProc    = HListWndProc;
+    wndclass.cbClsExtra     = 0;
+    wndclass.cbWndExtra     = 4;
+    wndclass.hInstance      = hInstance;
+    wndclass.hIcon          = NULL;
+    wndclass.hCursor        = LoadCursor( NULL, IDC_ARROW );
+    wndclass.hbrBackground  = (HBRUSH) (COLOR_WINDOW + 1);
+    wndclass.lpszMenuName   = NULL;
+    wndclass.lpszClassName  = CLASS_NAME;
+    if (!RegisterClass( &wndclass )) {
+        return FALSE;
+    }
+
+    return TRUE;
+}
+
+VOID
+CollapseNode(
+    HWND       hwnd,
+    LPITEMDATA lpid,
+    DWORD      nItem
+    )
+{
+    DWORD       i;
+    LPITEMDATA  lpidChild;
+
+
+    for (i=0; i<lpid->nchild; i++) {
+        lpidChild = (LPITEMDATA) SendMessage( hwnd, LB_GETITEMDATA, nItem, 0 );
+        if (lpidChild->nchild) {
+            CollapseNode( hwnd, lpidChild, nItem+1 );
+        }
+        SendMessage( hwnd, LB_DELETESTRING, nItem, 0 );
+    }
+
+    lpid->nchild = 0;
+}
+
+LRESULT
+HListWndProc(
+    HWND    hwnd,
+    UINT    message,
+    WPARAM  wParam,
+    LPARAM  lParam
+    )
+{
+    RECT                cRect;
+    HFONT               hFont;
+    LPHLISTINFO         hli;
+    LPHLISTTYPE         hlt;
+    LPHLISTTYPE         hltNext;
+    LPMEASUREITEMSTRUCT lpmis;
+    LPDELETEITEMSTRUCT  lplis;
+    LPDRAWITEMSTRUCT    lpdis;
+    HBITMAP             hbmp;
+    HBITMAP             hbmpOld;
+    HDC                 hdc;
+    TEXTMETRIC          tm;
+    int                 x;
+    int                 y;
+    int                 nItem;
+    RECT                rcBitmap;
+    LPITEMDATA          lpid;
+    LPITEMDATA          lpidParent;
+    DWORD               type;
+    LPSTR               str;
+    DWORD               rval;
+    DWORD               level;
+    LPSTR               ref;
+    LPSTR               p;
+    POINT               pt;
+    DWORD               childnum;
+    DWORD               i;
+    HPEN                hpen;
+    HPEN                oldhpen;
+
+
+    switch (message) {
+        case WM_CREATE:
+            hli = (LPHLISTINFO) malloc( sizeof(HLISTINFO) );
+            ZeroMemory( hli, sizeof(HLISTINFO) );
+            GetClientRect( hwnd, &cRect );
+            hli->hwndList = CreateWindow(
+                "LISTBOX",
+                NULL,
+                DEFAULT_STYLE,
+                cRect.left,
+                cRect.top,
+                cRect.right  - cRect.left,
+                cRect.bottom - cRect.top,
+                hwnd,
+                NULL,
+                GetModuleHandle(NULL),
+                NULL );
+            hFont = GetStockObject( SYSTEM_FIXED_FONT );
+            SendMessage( hli->hwndList, WM_SETFONT, (WPARAM)hFont, (LPARAM)FALSE );
+            SetFocus( hli->hwndList );
+            SetWindowLong( hwnd, 0, (DWORD)hli );
+            break;
+
+        case WM_SIZE:
+            hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+            GetClientRect( hwnd, &cRect );
+            MoveWindow(
+                hli->hwndList,
+                cRect.left,
+                cRect.top,
+                cRect.right - cRect.left,
+                cRect.bottom - cRect.top,
+                TRUE );
+            break;
+
+        case WM_DESTROY:
+            hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+            hlt = hli->typeList;
+            while (hlt) {
+                hltNext = hlt->next;
+                free( hlt );
+                hlt = hltNext;
+            }
+            DestroyWindow( hli->hwndList );
+            hli->hwndList = NULL;
+            free( hli );
+            SetWindowLong( hwnd, 0, 0 );
+            break;
+
+        case WM_COMMAND:
+            if (HIWORD(wParam) == LBN_DBLCLK) {
+                hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+                if (hli->lpCallback) {
+                    nItem = SendMessage( hli->hwndList, LB_GETCURSEL, 0, 0 );
+
+                    lpidParent = (LPITEMDATA) SendMessage( hli->hwndList, LB_GETITEMDATA, nItem, 0 );
+
+                    y = 0;
+                    lpid = lpidParent;
+                    while (lpid) {
+                        y += (strlen(lpid->str) + 1);
+                        lpid = lpid->parent;
+                    }
+                    y += 16;
+                    p = ref = malloc( y );
+                    lpid = lpidParent;
+                    while (lpid) {
+                        strcpy( p, lpid->str );
+                        p += (strlen(p) + 1);
+                        lpid = lpid->parent;
+                    }
+                    *p = '\0';
+
+                    level = lpidParent->level + 1;
+                    type = lpidParent->type;
+                    str = lpidParent->str;
+                    rval = (hli->lpCallback)( &type, &str, ref, level, lpidParent->nchild );
+
+                    if (rval == HLB_COLLAPSE) {
+                        CollapseNode( hli->hwndList, lpidParent, nItem+1 );
+                        break;
+                    }
+
+                    childnum = 1;
+                    while (rval != HLB_END) {
+                        if (rval == HLB_EXPAND) {
+                            hlt = hli->typeList;
+                            while (hlt && hlt->type != type) {
+                                hlt = hlt->next;
+                            }
+                            if (!hlt) {
+                                break;
+                            }
+                            lpidParent->nchild++;
+                            lpid = (LPITEMDATA) malloc( sizeof(ITEMDATA) );
+                            lpid->type = type;
+                            lpid->nchild = 0;
+                            lpid->level = level;
+                            lpid->bitmap = hlt->bitmap;
+                            lpid->str = _strdup( (LPSTR)str );
+                            lpid->parent = lpidParent;
+                            lpid->childnum = childnum++;
+                            nItem = SendMessage( hli->hwndList, LB_INSERTSTRING, nItem+1, (LPARAM)lpid->str );
+                            SendMessage( hli->hwndList, LB_SETITEMDATA, nItem, (LPARAM) lpid );
+                        }
+                        rval = (hli->lpCallback)( &type, &str, ref, level, 0 );
+                    }
+                    free( ref );
+                }
+            }
+            break;
+
+        case HLB_REGISTER_CALLBACK:
+            hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+            hli->lpCallback = (HLISTCALLBACK) lParam;
+            return 1;
+
+        case HLB_REGISTER_TYPE:
+            //
+            // wParam = type token
+            // lParam = the bitmap
+            //
+            hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+            if (!hli->typeList) {
+                hli->typeList = (LPHLISTTYPE) malloc( sizeof(HLISTTYPE) );
+                hlt = hli->typeList;
+            } else {
+                hlt = hli->typeList;
+                while (hlt->next) {
+                    hlt = hlt->next;
+                }
+                hlt->next = (LPHLISTTYPE) malloc( sizeof(HLISTTYPE) );
+                hlt = hlt->next;
+            }
+            hlt->type = (WPARAM) wParam;
+            hlt->bitmap = (HBITMAP) lParam;
+            hlt->next = NULL;
+            return 1;
+
+        case HLB_ADDSTRING:
+            //
+            // wParam = type
+            // lParam = string
+            //
+            hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+            hlt = hli->typeList;
+            while (hlt && hlt->type != wParam) {
+                hlt = hlt->next;
+            }
+            if (!hlt) {
+                return 0;
+            }
+            lpid = (LPITEMDATA) malloc( sizeof(ITEMDATA) );
+            lpid->type = hlt->type;
+            lpid->level = 0;
+            lpid->nchild = 0;
+            lpid->bitmap = hlt->bitmap;
+            lpid->str = _strdup( (LPSTR)lParam );
+            lpid->parent = NULL;
+            lpid->childnum = 0;
+            nItem = SendMessage( hli->hwndList, LB_ADDSTRING, 0, (LPARAM)lpid->str );
+            SendMessage( hli->hwndList, LB_SETITEMDATA, nItem, (LPARAM) lpid );
+            return 1;
+
+        case WM_MEASUREITEM:
+            lpmis = (LPMEASUREITEMSTRUCT) lParam;
+            lpmis->itemHeight  = YBITMAP;
+            return 1;
+
+        case WM_DELETEITEM:
+            lplis = (LPDELETEITEMSTRUCT) lParam;
+            lpid = (LPITEMDATA) lplis->itemData;
+            free( lpid->str );
+            free( lpid );
+            return 1;
+
+        case WM_DRAWITEM:
+            lpdis = (LPDRAWITEMSTRUCT) lParam;
+
+            if (lpdis->itemID == -1) {
+                break;
+            }
+
+            switch (lpdis->itemAction) {
+                case ODA_SELECT:
+                case ODA_DRAWENTIRE:
+                    lpid = (LPITEMDATA) SendMessage( lpdis->hwndItem, LB_GETITEMDATA, lpdis->itemID, 0 );
+                    hbmp = lpid->bitmap;
+
+                    hdc = CreateCompatibleDC( lpdis->hDC );
+                    hbmpOld = SelectObject( hdc, hbmp );
+
+                    lpdis->rcItem.left +=  (lpid->level * INDENT);
+
+                    BitBlt(
+                        lpdis->hDC,
+                        lpdis->rcItem.left,
+                        lpdis->rcItem.top,
+                        lpdis->rcItem.right - lpdis->rcItem.left,
+                        lpdis->rcItem.bottom - lpdis->rcItem.top,
+                        hdc,
+                        0,
+                        0,
+                        SRCCOPY );
+
+                    GetTextMetrics( lpdis->hDC, &tm );
+
+                    y = (lpdis->rcItem.bottom + lpdis->rcItem.top - tm.tmHeight) / 2;
+
+                    TextOut( lpdis->hDC, XBITMAP + MARGIN + (lpid->level * INDENT), y, lpid->str, strlen(lpid->str) );
+
+                    SelectObject( hdc, hbmpOld );
+
+                    //
+                    // now draw lines
+                    //
+                    if (lpid->level) {
+
+                        hpen = CreatePen( PS_SOLID, 1, LINE_COLOR );
+                        oldhpen = SelectObject( lpdis->hDC, hpen );
+
+                        y = lpdis->rcItem.top + ((lpdis->rcItem.bottom - lpdis->rcItem.top) / 2);
+                        MoveToEx(
+                            lpdis->hDC,
+                            lpdis->rcItem.left - 1,
+                            y,
+                            &pt );
+
+                        LineTo(
+                            lpdis->hDC,
+                            lpdis->rcItem.left - MIDDLE,
+                            y );
+
+                        MoveToEx(
+                            lpdis->hDC,
+                            lpdis->rcItem.left - MIDDLE,
+                            lpdis->rcItem.top,
+                            &pt );
+
+                        if (lpid->childnum < lpid->parent->nchild) {
+                            y = lpdis->rcItem.bottom;
+                        } else {
+                            y++;
+                        }
+
+                        LineTo(
+                            lpdis->hDC,
+                            lpdis->rcItem.left - MIDDLE,
+                            y );
+
+                        if (lpid->level > 1) {
+                            x = lpdis->rcItem.left - MIDDLE;
+                            y = lpdis->rcItem.top;
+                            for (i=1; i<lpid->level; i++) {
+                                MoveToEx(
+                                    lpdis->hDC,
+                                    x - (i * INDENT),
+                                    y,
+                                    &pt );
+                                LineTo(
+                                    lpdis->hDC,
+                                    x - (i * INDENT),
+                                    lpdis->rcItem.bottom );
+                            }
+                        }
+
+                        SelectObject( lpdis->hDC, oldhpen );
+                        DeleteObject( hpen );
+                    }
+
+                    DeleteDC( hdc );
+
+                    if (lpdis->itemState & ODS_SELECTED) {
+                        rcBitmap.left = lpdis->rcItem.left;
+                        rcBitmap.top = lpdis->rcItem.top;
+                        rcBitmap.right = lpdis->rcItem.left + XBITMAP + (tm.tmMaxCharWidth * strlen(lpid->str)) + MARGIN + 2;
+                        rcBitmap.bottom = lpdis->rcItem.top + YBITMAP;
+                        DrawFocusRect( lpdis->hDC, &rcBitmap );
+                    }
+
+                    break;
+
+                case ODA_FOCUS:
+                    break;
+            }
+            return 1;
+
+        case LB_ADDSTRING:
+            return SendMessage( hwnd, HLB_ADDSTRING, 1, lParam );
+
+        case LB_INSERTSTRING:
+        case LB_DELETESTRING:
+        case LB_SELITEMRANGEEX:
+        case LB_RESETCONTENT:
+        case LB_SETSEL:
+        case LB_SETCURSEL:
+        case LB_GETSEL:
+        case LB_GETCURSEL:
+        case LB_GETTEXT:
+        case LB_GETTEXTLEN:
+        case LB_GETCOUNT:
+        case LB_SELECTSTRING:
+        case LB_DIR:
+        case LB_ADDFILE:
+        case LB_GETTOPINDEX:
+        case LB_FINDSTRING:
+        case LB_GETSELCOUNT:
+        case LB_GETSELITEMS:
+        case LB_SETTABSTOPS:
+        case LB_GETHORIZONTALEXTENT:
+        case LB_SETHORIZONTALEXTENT:
+        case LB_SETCOLUMNWIDTH:
+        case LB_SETTOPINDEX:
+        case LB_GETITEMRECT:
+        case LB_GETITEMDATA:
+        case LB_SETITEMDATA:
+        case LB_SELITEMRANGE:
+        case LB_SETANCHORINDEX:
+        case LB_GETANCHORINDEX:
+        case LB_SETCARETINDEX:
+        case LB_GETCARETINDEX:
+        case LB_SETITEMHEIGHT:
+        case LB_GETITEMHEIGHT:
+        case LB_FINDSTRINGEXACT:
+        case LB_SETLOCALE:
+        case LB_GETLOCALE:
+        case LB_SETCOUNT:
+            hli = (LPHLISTINFO) GetWindowLong( hwnd, 0 );
+            return SendMessage( hli->hwndList, message, wParam, lParam );
+    }
+
+    return DefWindowProc( hwnd, message, wParam, lParam );
+}
diff --git a/private/sdktools/instaler/hlist.h b/private/sdktools/instaler/hlist.h
new file mode 100644
index 000000000..61a63a98f
--- /dev/null
+++ b/private/sdktools/instaler/hlist.h
@@ -0,0 +1,13 @@
+
+//
+// hlist defines
+//
+#define HLB_ADDSTRING           WM_USER+100
+#define HLB_INSERTSTRING        WM_USER+101
+#define HLB_REGISTER_TYPE       WM_USER+102
+#define HLB_REGISTER_CALLBACK   WM_USER+103
+
+#define HLB_IGNORE              0
+#define HLB_EXPAND              1
+#define HLB_COLLAPSE            2
+#define HLB_END                 3
diff --git a/private/sdktools/instaler/i386/machine.c b/private/sdktools/instaler/i386/machine.c
new file mode 100644
index 000000000..9f5b120d5
--- /dev/null
+++ b/private/sdktools/instaler/i386/machine.c
@@ -0,0 +1,332 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    machine.c
+
+Abstract:
+
+    This file contains machine specific code to support the INSTALER
+    program.  Specifically, routines to fetch parameters from the
+    registers/stack of a target process, routines to set a breakpoint
+    and step over an instruction at a breakpoint.
+
+Author:
+
+    Steve Wood (stevewo) 10-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+#define BREAKPOINT_OPCODE 0xCC
+#define INT_OPCODE 0xCD
+
+UCHAR InstructionBuffer = BREAKPOINT_OPCODE;
+PVOID BreakpointInstruction = (PVOID)&InstructionBuffer;
+ULONG SizeofBreakpointInstruction = sizeof( InstructionBuffer );
+
+BOOLEAN
+SkipOverHardcodedBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PVOID BreakpointAddress
+    )
+{
+    UCHAR InstructionByte;
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    if (!ReadMemory( Process,
+                     BreakpointAddress,
+                     &InstructionByte,
+                     sizeof( InstructionByte ),
+                     "hard coded breakpoint"
+                   )
+       ) {
+        return FALSE;
+        }
+
+    if (InstructionByte == BREAKPOINT_OPCODE) {
+        Context.Eip = (ULONG)((PCHAR)BreakpointAddress + 1);
+        }
+    else
+    if (InstructionByte == INT_OPCODE) {
+        Context.Eip = (ULONG)((PCHAR)BreakpointAddress + 2);
+        }
+    else {
+        return FALSE;
+        }
+
+    if (!SetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to set context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
+
+
+BOOLEAN
+ExtractProcedureParameters(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PULONG ReturnAddress,
+    ULONG SizeOfParameters,
+    PULONG Parameters
+    )
+{
+    UINT i;
+    ULONG NumberOfParameters;
+    CONTEXT Context;
+    ULONG StackBuffer[ 1+31 ];
+
+    NumberOfParameters = SizeOfParameters / sizeof( ULONG );
+    if ((NumberOfParameters * sizeof( ULONG )) != SizeOfParameters ||
+        NumberOfParameters > 31
+       ) {
+        DbgEvent( INTERNALERROR, ( "Invalid parameter size %x\n", SizeOfParameters ) );
+        return FALSE;
+        }
+
+    Context.ContextFlags = CONTEXT_CONTROL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    if (!ReadMemory( Process,
+                     (PVOID)Context.Esp,
+                     StackBuffer,
+                     SizeOfParameters +  sizeof( ULONG ),
+                     "parameters"
+                   )
+       ) {
+        return FALSE;
+        }
+
+    *ReturnAddress = StackBuffer[ 0 ];
+    for (i=0; i<NumberOfParameters; i++) {
+        Parameters[ i ] = StackBuffer[ 1+i ];
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+ExtractProcedureReturnValue(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PVOID ReturnValue,
+    ULONG SizeOfReturnValue
+    )
+{
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    switch (SizeOfReturnValue) {
+        case sizeof( UCHAR ):
+            *(PUCHAR)ReturnValue = (UCHAR)Context.Eax;
+            break;
+        case sizeof( USHORT ):
+            *(PUSHORT)ReturnValue = (USHORT)Context.Eax;
+            break;
+        case sizeof( ULONG ):
+            *(PULONG)ReturnValue = (ULONG)Context.Eax;
+            break;
+        case sizeof( ULONGLONG ):
+            *(PULONGLONG)ReturnValue = (ULONGLONG)Context.Edx << 32 | Context.Eax;
+            break;
+        default:
+            DbgEvent( INTERNALERROR, ( "Invalid return value size (%u)\n", SizeOfReturnValue ) );
+            return FALSE;
+        }
+
+    return TRUE;
+}
+
+BOOLEAN
+SetProcedureReturnValue(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PVOID ReturnValue,
+    ULONG SizeOfReturnValue
+    )
+{
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    switch (SizeOfReturnValue) {
+        case sizeof( UCHAR ):
+            (UCHAR)Context.Eax = *(PUCHAR)ReturnValue;
+            break;
+        case sizeof( USHORT ):
+            (USHORT)Context.Eax = *(PUSHORT)ReturnValue;
+            break;
+        case sizeof( ULONG ):
+            (ULONG)Context.Eax = *(PULONG)ReturnValue;
+            break;
+        case sizeof( ULONGLONG ):
+            (ULONG)Context.Eax = *(PULONG)ReturnValue;
+            (ULONG)Context.Edx = *((PULONG)ReturnValue + 1);
+            break;
+        default:
+            DbgEvent( INTERNALERROR, ( "Invalid return value size (%u)\n", SizeOfReturnValue ) );
+            return FALSE;
+        }
+
+    if (!SetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to set context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
+
+BOOLEAN
+ForceReturnToCaller(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    ULONG SizeOfParameters,
+    PVOID ReturnAddress,
+    PVOID ReturnValue,
+    ULONG SizeOfReturnValue
+    )
+{
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    switch (SizeOfReturnValue) {
+        case sizeof( UCHAR ):
+            (UCHAR)Context.Eax = *(PUCHAR)ReturnValue;
+            break;
+        case sizeof( USHORT ):
+            (USHORT)Context.Eax = *(PUSHORT)ReturnValue;
+            break;
+        case sizeof( ULONG ):
+            (ULONG)Context.Eax = *(PULONG)ReturnValue;
+            break;
+        case sizeof( ULONGLONG ):
+            (ULONG)Context.Eax = *(PULONG)ReturnValue;
+            (ULONG)Context.Edx = *((PULONG)ReturnValue + 1);
+            break;
+        default:
+            DbgEvent( INTERNALERROR, ( "Invalid return value size (%u)\n", SizeOfReturnValue ) );
+            return FALSE;
+        }
+
+    Context.Eip = (ULONG)ReturnAddress;
+    Context.Esp = Context.Esp + sizeof( ReturnAddress ) + SizeOfParameters;
+
+    if (!SetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to set context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
+
+
+
+BOOLEAN
+UndoReturnAddressBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    )
+{
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    Context.Eip -= 1;       // Back up to where breakpoint instruction was
+    if (!SetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to set context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
+
+
+BOOLEAN
+BeginSingleStepBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    )
+{
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    Context.Eip -= 1;       // Back up to where breakpoint instruction was
+    Context.EFlags |= V86FLAGS_TRACE;
+    if (!SetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to set context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
+
+
+BOOLEAN
+EndSingleStepBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    )
+{
+    CONTEXT Context;
+
+    Context.ContextFlags = CONTEXT_FULL;
+    if (!GetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to get context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+
+    Context.EFlags &= ~V86FLAGS_TRACE;
+    if (!SetThreadContext( Thread->Handle, &Context )) {
+        DbgEvent( INTERNALERROR, ( "Failed to set context for thread %x (%x) - %u\n", Thread->Id, Thread->Handle, GetLastError() ) );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
diff --git a/private/sdktools/instaler/i386/sources b/private/sdktools/instaler/i386/sources
new file mode 100644
index 000000000..96beda740
--- /dev/null
+++ b/private/sdktools/instaler/i386/sources
@@ -0,0 +1,32 @@
+i386_SOURCES=..\instaler.rc \
+             ..\instutil.c  \
+             ..\iml.c       \
+             ..\init.c      \
+             ..\handler.c   \
+             ..\debug.c     \
+             ..\process.c   \
+             ..\handledb.c  \
+             ..\namedb.c    \
+             ..\file.c      \
+             ..\key.c       \
+             ..\ini.c       \
+             ..\error.c     \
+             ..\event.c     \
+             i386\machine.c
+
+UMTYPE=console
+UMAPPL=instaler*showinst*undoinst*compinst
+UMTEST=testins1*testins2
+UMLIBS=\nt\public\sdk\lib\*\setargv.obj \
+       obj\*\instaler.lib               \
+       \nt\public\sdk\lib\*\ntdll.lib   \
+       \nt\public\sdk\lib\*\user32.lib
+UMRES=$(@R).res
+
+NTTARGETFILE0=errormsg.h         \
+              obj\*\instaler.res \
+              obj\*\testins1.res \
+              obj\*\testins2.res \
+              obj\*\showinst.res \
+              obj\*\undoinst.res \
+              obj\*\compinst.res
diff --git a/private/sdktools/instaler/iml.c b/private/sdktools/instaler/iml.c
new file mode 100644
index 000000000..5e8dbb7f1
--- /dev/null
+++ b/private/sdktools/instaler/iml.c
@@ -0,0 +1,481 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    iml.c
+
+Abstract:
+
+    This module contains routines for creating and accessing Installation
+    Modification Log files (.IML)
+
+Author:
+
+    Steve Wood (stevewo) 15-Jan-1996
+
+Revision History:
+
+--*/
+
+#include "instutil.h"
+#include "iml.h"
+
+PWSTR
+FormatImlPath(
+    PWSTR DirectoryPath,
+    PWSTR InstallationName
+    )
+{
+    PWSTR ImlPath;
+    ULONG n;
+
+    n = wcslen( DirectoryPath ) + wcslen( InstallationName ) + 8;
+    ImlPath = HeapAlloc( GetProcessHeap(), 0, (n  * sizeof( WCHAR )) );
+    if (ImlPath != NULL) {
+        _snwprintf( ImlPath, n, L"%s%s.IML", DirectoryPath, InstallationName );
+        }
+
+    return ImlPath;
+}
+
+
+PINSTALLATION_MODIFICATION_LOGFILE
+CreateIml(
+    PWSTR ImlPath,
+    BOOLEAN IncludeCreateFileContents
+    )
+{
+    HANDLE FileHandle;
+    PINSTALLATION_MODIFICATION_LOGFILE pIml;
+
+    pIml = NULL;
+    FileHandle = CreateFile( ImlPath,
+                             GENERIC_READ | GENERIC_WRITE,
+                             FILE_SHARE_READ,
+                             NULL,
+                             OPEN_ALWAYS,
+                             0,
+                             NULL
+                           );
+    if (FileHandle != INVALID_HANDLE_VALUE) {
+        pIml = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( *pIml ) );
+        if (pIml != NULL) {
+            pIml->Signature = IML_SIGNATURE;
+            pIml->FileHandle = FileHandle;
+            pIml->FileOffset = ROUND_UP( sizeof( *pIml ), 8 );
+            if (IncludeCreateFileContents) {
+                pIml->Flags = IML_FLAG_CONTAINS_NEWFILECONTENTS;
+                }
+
+            SetFilePointer( pIml->FileHandle, pIml->FileOffset, NULL, FILE_BEGIN );
+            }
+        }
+
+    return pIml;
+}
+
+
+PINSTALLATION_MODIFICATION_LOGFILE
+LoadIml(
+    PWSTR ImlPath
+    )
+{
+    HANDLE FileHandle, MappingHandle;
+    PINSTALLATION_MODIFICATION_LOGFILE pIml;
+
+    pIml = NULL;
+    FileHandle = CreateFile( ImlPath,
+                             GENERIC_READ,
+                             FILE_SHARE_READ,
+                             NULL,
+                             OPEN_EXISTING,
+                             0,
+                             NULL
+                           );
+    if (FileHandle != INVALID_HANDLE_VALUE) {
+        MappingHandle = CreateFileMapping( FileHandle,
+                                           NULL,
+                                           PAGE_READONLY,
+                                           0,
+                                           0,
+                                           NULL
+                                         );
+        CloseHandle( FileHandle );
+        if (MappingHandle != NULL) {
+            pIml = MapViewOfFile( MappingHandle,
+                                  FILE_MAP_READ,
+                                  0,
+                                  0,
+                                  0
+                                );
+            CloseHandle( MappingHandle );
+            if (pIml != NULL) {
+                if (pIml->Signature != IML_SIGNATURE) {
+                    UnmapViewOfFile( pIml );
+                    pIml = NULL;
+                    SetLastError( ERROR_BAD_FORMAT );
+                    }
+
+                }
+            }
+        }
+
+    return pIml;
+}
+
+
+BOOLEAN
+CloseIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml
+    )
+{
+    HANDLE FileHandle;
+    BOOLEAN Result;
+    ULONG BytesWritten;
+
+    if (pIml->FileHandle == NULL) {
+        if (!UnmapViewOfFile( pIml )) {
+            return FALSE;
+            }
+        else {
+            Result = TRUE;
+            }
+        }
+    else {
+        FileHandle = pIml->FileHandle;
+        pIml->FileHandle = NULL;
+        if (!SetEndOfFile( FileHandle ) ||
+            SetFilePointer( FileHandle, 0, NULL, FILE_BEGIN ) != 0 ||
+            !WriteFile( FileHandle,
+                        pIml,
+                        sizeof( *pIml ),
+                        &BytesWritten,
+                        NULL
+                      ) ||
+            BytesWritten != sizeof( *pIml )
+           ) {
+            Result = FALSE;
+            }
+        else {
+            Result = TRUE;
+            }
+        CloseHandle( FileHandle );
+        }
+
+    return Result;
+}
+
+
+POFFSET
+ImlWrite(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PVOID p,
+    ULONG Size
+    )
+{
+    POFFSET Result;
+    ULONG BytesWritten;
+
+    if (!WriteFile( pIml->FileHandle,
+                    p,
+                    Size,
+                    &BytesWritten,
+                    NULL
+                  ) ||
+        BytesWritten != Size
+       ) {
+        return 0;
+        }
+
+    Result = pIml->FileOffset;
+    pIml->FileOffset += ROUND_UP( Size, 8 );
+    SetFilePointer( pIml->FileHandle,
+                    pIml->FileOffset,
+                    NULL,
+                    FILE_BEGIN
+                  );
+    return Result;
+}
+
+POFFSET
+ImlWriteString(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PWSTR Name
+    )
+{
+    if (Name == NULL) {
+        return 0;
+        }
+    else {
+        return ImlWrite( pIml, Name, (wcslen( Name ) + 1) * sizeof( WCHAR ) );
+        }
+}
+
+
+POFFSET
+ImlWriteFileContents(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    PWSTR FileName
+    )
+{
+    HANDLE hFindFirst, hFile, hMapping;
+    WIN32_FIND_DATA FindFileData;
+    PVOID p;
+    IML_FILE_RECORD_CONTENTS ImlFileContentsRecord;
+
+    hFindFirst = FindFirstFile( FileName, &FindFileData );
+    if (hFindFirst == INVALID_HANDLE_VALUE) {
+        return 0;
+        }
+    FindClose( hFindFirst );
+
+    ImlFileContentsRecord.LastWriteTime = FindFileData.ftLastWriteTime;
+    ImlFileContentsRecord.FileAttributes = FindFileData.dwFileAttributes;
+    if (!(ImlFileContentsRecord.FileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
+        ImlFileContentsRecord.FileSize = FindFileData.nFileSizeLow;
+        hFile = CreateFile( FileName,
+                            GENERIC_READ,
+                            FILE_SHARE_READ,
+                            NULL,
+                            OPEN_EXISTING,
+                            0,
+                            NULL
+                          );
+        if (hFile == INVALID_HANDLE_VALUE) {
+            printf( "*** CreateFile( '%ws' ) failed (%u)\n", FileName, GetLastError() );
+            return 0;
+            }
+
+        if (ImlFileContentsRecord.FileSize != 0) {
+            hMapping = CreateFileMapping( hFile,
+                                         NULL,
+                                         PAGE_READONLY,
+                                         0,
+                                         0,
+                                         NULL
+                                       );
+            CloseHandle( hFile );
+            hFile = NULL;
+            if (hMapping == NULL) {
+                printf( "*** CreateFileMapping( '%ws' ) failed (%u)\n", FileName, GetLastError() );
+                return 0;
+                }
+
+            p = MapViewOfFile( hMapping,
+                               FILE_MAP_READ,
+                               0,
+                               0,
+                               0
+                             );
+            CloseHandle( hMapping );
+            if (p == NULL) {
+                printf( "*** MapViewOfFile( '%ws' ) failed (%u)\n", FileName, GetLastError() );
+                return 0;
+                }
+            }
+        else {
+            CloseHandle( hFile );
+            p = NULL;
+            }
+        }
+    else {
+        ImlFileContentsRecord.FileSize = 0;
+        p = NULL;
+        }
+
+    ImlFileContentsRecord.Contents = ImlWrite( pIml, p, ImlFileContentsRecord.FileSize );
+    if (p != NULL) {
+        UnmapViewOfFile( p );
+        }
+
+    return ImlWrite( pIml,
+                     &ImlFileContentsRecord,
+                     sizeof( ImlFileContentsRecord )
+                   );
+}
+
+BOOLEAN
+ImlAddFileRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_FILE_ACTION Action,
+    PWSTR Name,
+    PWSTR BackupFileName,
+    PFILETIME BackupLastWriteTime,
+    DWORD BackupFileAttributes
+    )
+{
+    IML_FILE_RECORD ImlFileRecord;
+    IML_FILE_RECORD_CONTENTS ImlFileContentsRecord;
+
+    memset( &ImlFileRecord, 0, sizeof( ImlFileRecord ) );
+    ImlFileRecord.Action = Action;
+    ImlFileRecord.Name = ImlWriteString( pIml, Name );
+    if (Action == CreateNewFile) {
+        if ((pIml->Flags & IML_FLAG_CONTAINS_NEWFILECONTENTS) != 0) {
+            ImlFileRecord.NewFile = ImlWriteFileContents( pIml, Name );
+            }
+        }
+    else
+    if (Action == ModifyOldFile ||
+        Action == DeleteOldFile
+       ) {
+        if (BackupFileName != NULL) {
+            ImlFileRecord.OldFile = ImlWriteFileContents( pIml, BackupFileName );
+            }
+
+        if (Action == ModifyOldFile &&
+            (pIml->Flags & IML_FLAG_CONTAINS_NEWFILECONTENTS) != 0
+           ) {
+            ImlFileRecord.NewFile = ImlWriteFileContents( pIml, Name );
+            }
+        }
+    else {
+        ImlFileContentsRecord.LastWriteTime = *BackupLastWriteTime;
+        ImlFileContentsRecord.FileAttributes = BackupFileAttributes;
+        ImlFileContentsRecord.FileSize = 0;
+        ImlFileContentsRecord.Contents = 0;
+        ImlFileRecord.OldFile = ImlWrite( pIml,
+                                          &ImlFileContentsRecord,
+                                          sizeof( ImlFileContentsRecord )
+                                        );
+        }
+
+    ImlFileRecord.Next = pIml->FileRecords;
+    pIml->FileRecords = ImlWrite( pIml, &ImlFileRecord, sizeof( ImlFileRecord ) );
+    pIml->NumberOfFileRecords += 1;
+    return TRUE;
+}
+
+
+BOOLEAN
+ImlAddValueRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_VALUE_ACTION Action,
+    PWSTR Name,
+    DWORD ValueType,
+    ULONG ValueLength,
+    PVOID ValueData,
+    DWORD BackupValueType,
+    ULONG BackupValueLength,
+    PVOID BackupValueData,
+    POFFSET *Values
+    )
+{
+    IML_VALUE_RECORD ImlValueRecord;
+    IML_VALUE_RECORD_CONTENTS ImlValueContentsRecord;
+
+    memset( &ImlValueRecord, 0, sizeof( ImlValueRecord ) );
+    ImlValueRecord.Action = Action;
+    ImlValueRecord.Name = ImlWriteString( pIml, Name );
+    if (Action != DeleteOldValue) {
+        ImlValueContentsRecord.Type = ValueType;
+        ImlValueContentsRecord.Length = ValueLength;
+        ImlValueContentsRecord.Data = ImlWrite( pIml, ValueData, ValueLength );
+        ImlValueRecord.NewValue = ImlWrite( pIml,
+                                            &ImlValueContentsRecord,
+                                            sizeof( ImlValueContentsRecord )
+                                          );
+        }
+    if (Action != CreateNewValue) {
+        ImlValueContentsRecord.Type = BackupValueType;
+        ImlValueContentsRecord.Length = BackupValueLength;
+        ImlValueContentsRecord.Data = ImlWrite( pIml, BackupValueData, BackupValueLength );
+        ImlValueRecord.OldValue = ImlWrite( pIml,
+                                            &ImlValueContentsRecord,
+                                            sizeof( ImlValueContentsRecord )
+                                          );
+        }
+
+    ImlValueRecord.Next = *Values;
+    *Values = ImlWrite( pIml, &ImlValueRecord, sizeof( ImlValueRecord ) );
+    return TRUE;
+}
+
+
+BOOLEAN
+ImlAddKeyRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_KEY_ACTION Action,
+    PWSTR Name,
+    POFFSET Values
+    )
+{
+    IML_KEY_RECORD ImlKeyRecord;
+
+    memset( &ImlKeyRecord, 0, sizeof( ImlKeyRecord ) );
+    ImlKeyRecord.Action = Action;
+    ImlKeyRecord.Name = ImlWriteString( pIml, Name );
+    ImlKeyRecord.Values = Values;
+    ImlKeyRecord.Next = pIml->KeyRecords;
+    pIml->KeyRecords = ImlWrite( pIml, &ImlKeyRecord, sizeof( ImlKeyRecord ) );
+    pIml->NumberOfKeyRecords += 1;
+    return TRUE;
+}
+
+
+
+BOOLEAN
+ImlAddIniVariableRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_INIVARIABLE_ACTION Action,
+    PWSTR Name,
+    PWSTR OldValue,
+    PWSTR NewValue,
+    POFFSET *Variables
+    )
+{
+    IML_INIVARIABLE_RECORD ImlIniVariableRecord;
+
+    memset( &ImlIniVariableRecord, 0, sizeof( ImlIniVariableRecord ) );
+    ImlIniVariableRecord.Action = Action;
+    ImlIniVariableRecord.Name = ImlWriteString( pIml, Name );
+    ImlIniVariableRecord.OldValue = ImlWriteString( pIml, OldValue );
+    ImlIniVariableRecord.NewValue = ImlWriteString( pIml, NewValue );
+    ImlIniVariableRecord.Next = *Variables;
+    *Variables  = ImlWrite( pIml, &ImlIniVariableRecord, sizeof( ImlIniVariableRecord ) );
+    return TRUE;
+}
+
+BOOLEAN
+ImlAddIniSectionRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_INISECTION_ACTION Action,
+    PWSTR Name,
+    POFFSET Variables,
+    POFFSET *Sections
+    )
+{
+    IML_INISECTION_RECORD ImlIniSectionRecord;
+
+    memset( &ImlIniSectionRecord, 0, sizeof( ImlIniSectionRecord ) );
+    ImlIniSectionRecord.Action = Action;
+    ImlIniSectionRecord.Name = ImlWriteString( pIml, Name );
+    ImlIniSectionRecord.Variables = Variables;
+    ImlIniSectionRecord.Next = *Sections;
+    *Sections  = ImlWrite( pIml, &ImlIniSectionRecord, sizeof( ImlIniSectionRecord ) );
+    return TRUE;
+}
+
+BOOLEAN
+ImlAddIniRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_INI_ACTION Action,
+    PWSTR Name,
+    PFILETIME BackupLastWriteTime,
+    POFFSET Sections
+    )
+{
+    IML_INI_RECORD ImlIniRecord;
+
+    memset( &ImlIniRecord, 0, sizeof( ImlIniRecord ) );
+    ImlIniRecord.Action = Action;
+    ImlIniRecord.Name = ImlWriteString( pIml, Name );
+    ImlIniRecord.LastWriteTime = *BackupLastWriteTime;
+    ImlIniRecord.Sections = Sections;
+    ImlIniRecord.Next = pIml->IniRecords;
+    pIml->IniRecords = ImlWrite( pIml, &ImlIniRecord, sizeof( ImlIniRecord ) );
+    pIml->NumberOfIniRecords += 1;
+    return TRUE;
+}
diff --git a/private/sdktools/instaler/iml.h b/private/sdktools/instaler/iml.h
new file mode 100644
index 000000000..dea3eadb7
--- /dev/null
+++ b/private/sdktools/instaler/iml.h
@@ -0,0 +1,221 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    iml.h
+
+Abstract:
+
+    Header for for creating, accessing and manipulating Installation Modification
+    Log files (.IML extension) created by INSTALER.EXE
+
+Author:
+
+    Steve Wood (stevewo) 23-Jan-1996
+
+--*/
+
+typedef ULONG POFFSET;
+
+#define MP(t,b,o) ((t)((o) ? (PVOID)((ULONG)(b) + (o)) : NULL))
+
+typedef struct _INSTALLATION_MODIFICATION_LOGFILE {
+    ULONG Signature;
+    USHORT HeaderSize;
+    USHORT Flags;
+    HANDLE FileHandle;
+    ULONG FileOffset;
+    ULONG NumberOfFileRecords;
+    POFFSET FileRecords;            // IML_FILE_RECORD
+    ULONG NumberOfKeyRecords;
+    POFFSET KeyRecords;             // IML_KEY_RECORD
+    ULONG NumberOfIniRecords;
+    POFFSET IniRecords;             // IML_INI_RECORD
+} INSTALLATION_MODIFICATION_LOGFILE, *PINSTALLATION_MODIFICATION_LOGFILE;
+
+#define IML_SIGNATURE 0xFF0AA0FF
+
+#define IML_FLAG_CONTAINS_NEWFILECONTENTS 0x0001
+#define IML_FLAG_ACTIONS_UNDONE           0x0002
+
+PWSTR
+FormatImlPath(
+    PWSTR DirectoryPath,
+    PWSTR InstallationName
+    );
+
+PINSTALLATION_MODIFICATION_LOGFILE
+CreateIml(
+    PWSTR ImlPath,
+    BOOLEAN IncludeCreateFileContents
+    );
+
+PINSTALLATION_MODIFICATION_LOGFILE
+LoadIml(
+    PWSTR ImlPath
+    );
+
+BOOLEAN
+CloseIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml
+    );
+
+typedef enum _IML_FILE_ACTION {
+    CreateNewFile,
+    ModifyOldFile,
+    DeleteOldFile,
+    ModifyFileDateTime,
+    ModifyFileAttributes
+} IML_FILE_ACTION;
+
+typedef struct _IML_FILE_RECORD_CONTENTS {
+    FILETIME LastWriteTime;
+    DWORD FileAttributes;
+    DWORD FileSize;
+    POFFSET Contents;               // VOID
+} IML_FILE_RECORD_CONTENTS, *PIML_FILE_RECORD_CONTENTS;
+
+
+typedef struct _IML_FILE_RECORD {
+    POFFSET Next;                   // IML_FILE_RECORD
+    IML_FILE_ACTION Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET OldFile;                // IML_FILE_RECORD_CONTENTS
+    POFFSET NewFile;                // IML_FILE_RECORD_CONTENTS
+} IML_FILE_RECORD, *PIML_FILE_RECORD;
+
+BOOLEAN
+ImlAddFileRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_FILE_ACTION Action,
+    PWSTR Name,
+    PWSTR BackupFileName,
+    PFILETIME BackupLastWriteTime,
+    DWORD BackupFileAttributes
+    );
+
+typedef enum _IML_VALUE_ACTION {
+    CreateNewValue,
+    DeleteOldValue,
+    ModifyOldValue
+} IML_VALUE_ACTION;
+
+typedef struct _IML_VALUE_RECORD_CONTENTS {
+    DWORD Type;
+    DWORD Length;
+    POFFSET Data;                   // VOID
+} IML_VALUE_RECORD_CONTENTS, *PIML_VALUE_RECORD_CONTENTS;
+
+typedef struct _IML_VALUE_RECORD {
+    POFFSET Next;                   // IML_VALUE_RECORD
+    IML_VALUE_ACTION Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET OldValue;               // IML_VALUE_RECORD_CONTENTS
+    POFFSET NewValue;               // IML_VALUE_RECORD_CONTENTS
+} IML_VALUE_RECORD, *PIML_VALUE_RECORD;
+
+BOOLEAN
+ImlAddValueRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_VALUE_ACTION Action,
+    PWSTR Name,
+    DWORD ValueType,
+    ULONG ValueLength,
+    PVOID ValueData,
+    DWORD BackupValueType,
+    ULONG BackupValueLength,
+    PVOID BackupValueData,
+    POFFSET *Values                 // IML_VALUE_RECORD
+    );
+
+typedef enum _IML_KEY_ACTION {
+    CreateNewKey,
+    DeleteOldKey,
+    ModifyKeyValues
+} IML_KEY_ACTION;
+
+typedef struct _IML_KEY_RECORD {
+    POFFSET Next;                   // IML_KEY_RECORD
+    IML_KEY_ACTION Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET Values;                 // IML_VALUE_RECORD
+} IML_KEY_RECORD, *PIML_KEY_RECORD;
+
+BOOLEAN
+ImlAddKeyRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_KEY_ACTION Action,
+    PWSTR Name,
+    POFFSET Values                  // IML_VALUE_RECORD
+    );
+
+typedef enum _IML_INIVARIABLE_ACTION {
+    CreateNewVariable,
+    DeleteOldVariable,
+    ModifyOldVariable
+} IML_INIVARIABLE_ACTION;
+
+typedef struct _IML_INIVARIABLE_RECORD {
+    POFFSET Next;                   // IML_INIVARIABLE_RECORD
+    IML_INIVARIABLE_ACTION Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET OldValue;               // WCHAR
+    POFFSET NewValue;               // WCHAR
+} IML_INIVARIABLE_RECORD, *PIML_INIVARIABLE_RECORD;
+
+BOOLEAN
+ImlAddIniVariableRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_INIVARIABLE_ACTION Action,
+    PWSTR Name,
+    PWSTR OldValue,
+    PWSTR NewValue,
+    POFFSET *Variables              // IML_INIVARIABLE_RECORD
+    );
+
+typedef enum _IML_INISECTION_ACTION {
+    CreateNewSection,
+    DeleteOldSection,
+    ModifySectionVariables
+} IML_INISECTION_ACTION;
+
+typedef struct _IML_INISECTION_RECORD {
+    POFFSET Next;                   // IML_INISECTION_RECORD
+    IML_INISECTION_ACTION Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET Variables;              // IML_INIVARIABLE_RECORD
+} IML_INISECTION_RECORD, *PIML_INISECTION_RECORD;
+
+BOOLEAN
+ImlAddIniSectionRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_INISECTION_ACTION Action,
+    PWSTR Name,
+    POFFSET Variables,              // IML_INIVARIABLE_RECORD
+    POFFSET *Sections               // IML_INISECTION_RECORD
+    );
+
+typedef enum _IML_INI_ACTION {
+    CreateNewIniFile,
+    ModifyOldIniFile
+} IML_INI_ACTION;
+
+typedef struct _IML_INI_RECORD {
+    POFFSET Next;                   // IML_INI_RECORD
+    IML_INI_ACTION Action;
+    POFFSET Name;                   // WCHAR
+    POFFSET Sections;               // IML_INISECTION_RECORD
+    FILETIME LastWriteTime;
+} IML_INI_RECORD, *PIML_INI_RECORD;
+
+
+BOOLEAN
+ImlAddIniRecord(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml,
+    IML_INI_ACTION Action,
+    PWSTR Name,
+    PFILETIME BackupLastWriteTime,
+    POFFSET Sections                // IML_INISECTION_RECORD
+    );
diff --git a/private/sdktools/instaler/ini.c b/private/sdktools/instaler/ini.c
new file mode 100644
index 000000000..f50a177c7
--- /dev/null
+++ b/private/sdktools/instaler/ini.c
@@ -0,0 +1,382 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    ini.c
+
+Abstract:
+
+    This module implements the functions to save references to .INI file
+    sections and values for the INSTALER program.  Part of each reference is
+    a a backup copy of sections and values for an .INI file.
+
+Author:
+
+    Steve Wood (stevewo) 22-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+
+BOOLEAN
+CreateIniFileReference(
+    PWSTR Name,
+    PINI_FILE_REFERENCE *ReturnedReference
+    )
+{
+    PINI_FILE_REFERENCE p;
+    PINI_SECTION_REFERENCE p1;
+    PINI_VARIABLE_REFERENCE p2;
+    PWSTR SectionName;
+    PWSTR VariableName;
+    PWSTR VariableValue;
+    UNICODE_STRING UnicodeString;
+    PLIST_ENTRY Head, Next;
+    ULONG n, n1;
+    BOOLEAN Result;
+    HANDLE FindHandle;
+    WIN32_FIND_DATA FindFileData;
+
+    p = FindIniFileReference( Name );
+    if (p != NULL) {
+        *ReturnedReference = p;
+        return TRUE;
+        }
+
+    p = AllocMem( sizeof( *p ) );
+    if (p == NULL) {
+        return FALSE;
+        }
+
+    p->Name = Name;
+    InitializeListHead( &p->SectionReferencesListHead );
+    InsertTailList( &IniReferenceListHead, &p->Entry );
+    FindHandle = FindFirstFile( Name, &FindFileData );
+    if (FindHandle == INVALID_HANDLE_VALUE) {
+        p->Created = TRUE;
+        *ReturnedReference = p;
+        return TRUE;
+        }
+    FindClose( FindHandle );
+    p->BackupLastWriteTime = FindFileData.ftLastWriteTime;
+
+    GrowTemporaryBuffer( n = 0xF000 );
+    SectionName = TemporaryBuffer;
+
+    Result = TRUE;
+    n1 = GetPrivateProfileStringW( NULL,
+                                   NULL,
+                                   L"",
+                                   SectionName,
+                                   n,
+                                   Name
+                                 );
+    if (n1 == 0 || n1 == n-2) {
+        Result = FALSE;
+        }
+    else {
+        while (*SectionName != UNICODE_NULL) {
+            p1 = AllocMem( sizeof( *p1 ) );
+            if (p1 == NULL) {
+                Result = FALSE;
+                break;
+                }
+
+            RtlInitUnicodeString( &UnicodeString, SectionName );
+            p1->Name = AddName( &UnicodeString );
+            if (FindIniSectionReference( p, p1->Name, FALSE )) {
+                FreeMem( &p1 );
+                }
+            else {
+                InitializeListHead( &p1->VariableReferencesListHead );
+                InsertTailList( &p->SectionReferencesListHead, &p1->Entry );
+                }
+            while (*SectionName++ != UNICODE_NULL) {
+                }
+            }
+        }
+
+    VariableName = TemporaryBuffer;
+    Head = &p->SectionReferencesListHead;
+    Next = Head->Flink;
+    while (Result && (Head != Next)) {
+        p1 = CONTAINING_RECORD( Next, INI_SECTION_REFERENCE, Entry );
+        n1 = GetPrivateProfileSectionW( p1->Name,
+                                        VariableName,
+                                        n,
+                                        Name
+                                      );
+        if (n1 == n-2) {
+            Result = FALSE;
+            break;
+            }
+
+        while (*VariableName != UNICODE_NULL) {
+            VariableValue = VariableName;
+            while (*VariableValue != UNICODE_NULL && *VariableValue != L'=') {
+                VariableValue += 1;
+                }
+
+            if (*VariableValue != L'=') {
+                Result = FALSE;
+                break;
+                }
+            *VariableValue++ = UNICODE_NULL;
+
+            p2 = AllocMem( sizeof( *p2 ) + ((wcslen( VariableValue ) + 1) * sizeof( WCHAR )) );
+            if (p2 == NULL) {
+                Result = FALSE;
+                break;
+                }
+            RtlInitUnicodeString( &UnicodeString, VariableName );
+            p2->Name = AddName( &UnicodeString );
+            p2->OriginalValue = (PWSTR)(p2+1);
+            wcscpy( p2->OriginalValue, VariableValue );
+            InsertTailList( &p1->VariableReferencesListHead, &p2->Entry );
+
+            VariableName = VariableValue;
+            while (*VariableName++ != UNICODE_NULL) {
+                }
+            }
+
+        Next = Next->Flink;
+        }
+
+
+    if (Result) {
+        *ReturnedReference = p;
+        }
+    else {
+        DestroyIniFileReference( p );
+        }
+
+    return Result;
+}
+
+
+BOOLEAN
+DestroyIniFileReference(
+    PINI_FILE_REFERENCE p
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PINI_SECTION_REFERENCE p1;
+
+    Head = &p->SectionReferencesListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p1 = CONTAINING_RECORD( Next, INI_SECTION_REFERENCE, Entry );
+        Next = Next->Flink;
+        DestroyIniSectionReference( p1 );
+        }
+
+    RemoveEntryList( &p->Entry );
+    FreeMem( &p );
+    return TRUE;
+}
+
+
+BOOLEAN
+DestroyIniSectionReference(
+    PINI_SECTION_REFERENCE p1
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PINI_VARIABLE_REFERENCE p2;
+
+    Head = &p1->VariableReferencesListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p2 = CONTAINING_RECORD( Next, INI_VARIABLE_REFERENCE, Entry );
+        Next = Next->Flink;
+        DestroyIniVariableReference( p2 );
+        }
+
+    RemoveEntryList( &p1->Entry );
+    FreeMem( &p1 );
+    return TRUE;
+}
+
+
+BOOLEAN
+DestroyIniVariableReference(
+    PINI_VARIABLE_REFERENCE p2
+    )
+{
+    RemoveEntryList( &p2->Entry );
+    FreeMem( &p2 );
+    return TRUE;
+}
+
+
+PINI_FILE_REFERENCE
+FindIniFileReference(
+    PWSTR Name
+    )
+{
+    PINI_FILE_REFERENCE p;
+    PLIST_ENTRY Next, Head;
+
+    Head = &IniReferenceListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, INI_FILE_REFERENCE, Entry );
+        if (p->Name == Name) {
+            return p;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+PINI_SECTION_REFERENCE
+FindIniSectionReference(
+    PINI_FILE_REFERENCE p,
+    PWSTR Name,
+    BOOLEAN CreateOkay
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PINI_SECTION_REFERENCE p1;
+
+    Head = &p->SectionReferencesListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p1 = CONTAINING_RECORD( Next, INI_SECTION_REFERENCE, Entry );
+        if (p1->Name == Name) {
+            return p1;
+            }
+
+        Next = Next->Flink;
+        }
+
+    if (CreateOkay) {
+        p1 = AllocMem( sizeof( *p1 ) );
+        if (p1 != NULL) {
+            p1->Created = TRUE;
+            p1->Name = Name;
+            InitializeListHead( &p1->VariableReferencesListHead );
+            InsertTailList( &p->SectionReferencesListHead, &p1->Entry );
+            }
+        }
+    else {
+        p1 = NULL;
+        }
+
+    return p1;
+}
+
+
+PINI_VARIABLE_REFERENCE
+FindIniVariableReference(
+    PINI_SECTION_REFERENCE p1,
+    PWSTR Name,
+    BOOLEAN CreateOkay
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PINI_VARIABLE_REFERENCE p2;
+
+    Head = &p1->VariableReferencesListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p2 = CONTAINING_RECORD( Next, INI_VARIABLE_REFERENCE, Entry );
+        if (p2->Name == Name) {
+            return p2;
+            }
+
+        Next = Next->Flink;
+        }
+
+    if (CreateOkay) {
+        p2 = AllocMem( sizeof( *p2 ) );
+        if (p2 != NULL) {
+            p2->Created = TRUE;
+            p2->Name = Name;
+            InsertTailList( &p1->VariableReferencesListHead, &p2->Entry );
+            }
+        }
+    else {
+        p2 = NULL;
+        }
+
+    return p2;
+}
+
+
+VOID
+DumpIniFileReferenceList(
+    FILE *LogFile
+    )
+{
+    PINI_FILE_REFERENCE p;
+    PINI_SECTION_REFERENCE p1;
+    PINI_VARIABLE_REFERENCE p2;
+    PLIST_ENTRY Head, Next;
+    PLIST_ENTRY Head1, Next1;
+    PLIST_ENTRY Head2, Next2;
+    POFFSET Variables;
+    POFFSET Sections;
+
+
+    Head = &IniReferenceListHead;
+    Next = Head->Blink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, INI_FILE_REFERENCE, Entry );
+        Sections = 0;
+        Head1 = &p->SectionReferencesListHead;
+        Next1 = Head1->Blink;
+        while (Head1 != Next1) {
+            p1 = CONTAINING_RECORD( Next1, INI_SECTION_REFERENCE, Entry );
+            Variables = 0;
+            Head2 = &p1->VariableReferencesListHead;
+            Next2 = Head2->Blink;
+            while (Head2 != Next2) {
+                p2 = CONTAINING_RECORD( Next2, INI_VARIABLE_REFERENCE, Entry );
+                if (p2->Created || p2->Deleted || p2->Modified) {
+                    ImlAddIniVariableRecord( pImlNew,
+                                             p2->Created ? CreateNewVariable :
+                                             p2->Deleted ? DeleteOldVariable : ModifyOldVariable,
+                                             p2->Name,
+                                             p2->OriginalValue,
+                                             p2->Value,
+                                             &Variables
+                                           );
+                    }
+                Next2 = Next2->Blink;
+                }
+
+            if (Variables != 0) {
+                ImlAddIniSectionRecord( pImlNew,
+                                        p1->Created ? CreateNewSection :
+                                        p1->Deleted ? DeleteOldSection :  ModifySectionVariables,
+                                        p1->Name,
+                                        Variables,
+                                        &Sections
+                                      );
+                }
+
+            Next1 = Next1->Blink;
+            }
+
+        if (Sections != 0) {
+            ImlAddIniRecord( pImlNew,
+                             p->Created ? CreateNewIniFile : ModifyOldIniFile,
+                             p->Name,
+                             &p->BackupLastWriteTime,
+                             Sections
+                           );
+            }
+
+        Next = Next->Blink;
+        }
+
+    return;
+}
diff --git a/private/sdktools/instaler/init.c b/private/sdktools/instaler/init.c
new file mode 100644
index 000000000..5a9a5c170
--- /dev/null
+++ b/private/sdktools/instaler/init.c
@@ -0,0 +1,770 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    init.c
+
+Abstract:
+
+    This is the initialization module for the INSTALER program.
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+#if TRACE_ENABLED
+ULONG EnabledTraceEvents = DBG_MASK_INTERNALERROR |
+                           DBG_MASK_MEMORYERROR;
+#endif
+
+MODULE_INFO ModuleInfo[ MAXIMUM_MODULE_INDEX ] = {
+    {L"NTDLL", NULL},
+    {L"KERNEL32", NULL},
+    {L"ADVAPI32", NULL}
+};
+
+
+
+API_INFO ApiInfo[ MAXIMUM_API_INDEX ] = {
+    {NTDLL_MODULE_INDEX,    "NtCreateFile",                 NULL, NtCreateFileHandler               , sizeof( CREATEFILE_PARAMETERS )                   , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtOpenFile",                   NULL, NtOpenFileHandler                 , sizeof( OPENFILE_PARAMETERS )                     , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtDeleteFile",                 NULL, NtDeleteFileHandler               , sizeof( DELETEFILE_PARAMETERS )                   , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtSetInformationFile",         NULL, NtSetInformationFileHandler       , sizeof( SETINFORMATIONFILE_PARAMETERS )           , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtQueryAttributesFile",        NULL, NtQueryAttributesFileHandler      , sizeof( QUERYATTRIBUTESFILE_PARAMETERS )          , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtQueryDirectoryFile",         NULL, NtQueryDirectoryFileHandler       , sizeof( QUERYDIRECTORYFILE_PARAMETERS )           , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtCreateKey",                  NULL, NtCreateKeyHandler                , sizeof( CREATEKEY_PARAMETERS )                    , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtOpenKey",                    NULL, NtOpenKeyHandler                  , sizeof( OPENKEY_PARAMETERS )                      , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtDeleteKey",                  NULL, NtDeleteKeyHandler                , sizeof( DELETEKEY_PARAMETERS )                    , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtSetValueKey",                NULL, NtSetValueKeyHandler              , sizeof( SETVALUEKEY_PARAMETERS )                  , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtDeleteValueKey",             NULL, NtDeleteValueKeyHandler           , sizeof( DELETEVALUEKEY_PARAMETERS )               , sizeof( NTSTATUS )},
+    {NTDLL_MODULE_INDEX,    "NtClose",                      NULL, NtCloseHandleHandler              , sizeof( CLOSEHANDLE_PARAMETERS )                  , sizeof( NTSTATUS )},
+    {KERNEL32_MODULE_INDEX, "GetVersion",                   NULL, GetVersionHandler                 , 0                                                 , sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "GetVersionExW",                NULL, GetVersionExWHandler              , sizeof( GETVERSIONEXW_PARAMETERS )                , sizeof( BOOL )},
+    {KERNEL32_MODULE_INDEX, "SetCurrentDirectoryA",         NULL, SetCurrentDirectoryAHandler       , sizeof( SETCURRENTDIRECTORYA_PARAMETERS )         , sizeof( BOOL )},
+    {KERNEL32_MODULE_INDEX, "SetCurrentDirectoryW",         NULL, SetCurrentDirectoryWHandler       , sizeof( SETCURRENTDIRECTORYW_PARAMETERS )         , sizeof( BOOL )},
+    {KERNEL32_MODULE_INDEX, "WritePrivateProfileStringA",   NULL, WritePrivateProfileStringAHandler , sizeof( WRITEPRIVATEPROFILESTRINGA_PARAMETERS )   , sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "WritePrivateProfileStringW",   NULL, WritePrivateProfileStringWHandler , sizeof( WRITEPRIVATEPROFILESTRINGW_PARAMETERS )   , sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "WritePrivateProfileSectionA",  NULL, WritePrivateProfileSectionAHandler, sizeof( WRITEPRIVATEPROFILESECTIONA_PARAMETERS )  , sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "WritePrivateProfileSectionW",  NULL, WritePrivateProfileSectionWHandler, sizeof( WRITEPRIVATEPROFILESECTIONW_PARAMETERS )  , sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "GetPrivateProfileStringW",     NULL, NULL, 0, sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "GetPrivateProfileStringA",     NULL, NULL, 0, sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "GetPrivateProfileSectionW",    NULL, NULL, 0, sizeof( DWORD )},
+    {KERNEL32_MODULE_INDEX, "GetPrivateProfileSectionA",    NULL, NULL, 0, sizeof( DWORD )},
+    {ADVAPI32_MODULE_INDEX, "RegConnectRegistryW",          NULL, RegConnectRegistryWHandler        , sizeof( REGCONNECTREGISTRYW_PARAMETERS )          , sizeof( DWORD )}
+};
+
+BOOLEAN
+LoadApplicationForDebug(
+    PWSTR CommandLine
+    );
+
+BOOLEAN
+LoadDriveLetterDefinitions( VOID );
+
+WCHAR WindowsDirectoryBuffer[ MAX_PATH ];
+UNICODE_STRING WindowsDirectory;
+
+BOOLEAN
+InitializeInstaler(
+    int argc,
+    char *argv[]
+    )
+{
+    UINT ModuleIndex, ApiIndex;
+    PWSTR CommandLine;
+    UINT i;
+    LPSTR s;
+    UCHAR c;
+    SYSTEM_INFO SystemInfo;
+    BOOLEAN ProcessingDebugSwitch;
+
+    InitCommonCode( "INSTALER",
+                    "[-9] [-r] [-dAE] CommandLine...",
+                    "-9 specifies that GetVersion should lie and tell application\n"
+                    "   that it is running on Windows 95\n"
+                    "-r specifies that attempts to do a wildcard scan of the root\n"
+                    "   directory of a drive should fail.\n"
+                    "-d specifies one or more debugging message options\n"
+                    "   A - shows all errors\n"
+                    "   E - shows all debug events\n"
+                    "   C - shows all create API calls\n"
+                  );
+
+    AppHeap = GetProcessHeap();
+    InstalerModuleHandle = GetModuleHandle( NULL );
+
+    GetWindowsDirectoryW( WindowsDirectoryBuffer, MAX_PATH );
+    RtlInitUnicodeString( &WindowsDirectory, WindowsDirectoryBuffer );
+
+    GetSystemInfo( &SystemInfo );
+
+    TemporaryBufferLengthGrowth = SystemInfo.dwPageSize;
+    TemporaryBufferMaximumLength = ((128 * 1024) + SystemInfo.dwAllocationGranularity - 1) &
+                                   ~SystemInfo.dwAllocationGranularity;
+    TemporaryBuffer = VirtualAlloc( NULL,
+                                    TemporaryBufferMaximumLength,
+                                    MEM_RESERVE,
+                                    PAGE_READWRITE
+                                  );
+    if (TemporaryBuffer == NULL) {
+        return FALSE;
+        }
+
+    InitializeListHead( &ProcessListHead );
+    InitializeListHead( &FileReferenceListHead );
+    InitializeListHead( &KeyReferenceListHead );
+    InitializeListHead( &IniReferenceListHead );
+    InitializeCriticalSection( &BreakTable );
+
+    //
+    // Loop over the table of modules and make sure each is loaded in our
+    // address space so we can access their export tables.
+    //
+    for (ModuleIndex=0; ModuleIndex<MAXIMUM_MODULE_INDEX; ModuleIndex++) {
+        ModuleInfo[ ModuleIndex ].ModuleHandle =
+            GetModuleHandle( ModuleInfo[ ModuleIndex ].ModuleName );
+
+        if (ModuleInfo[ ModuleIndex ].ModuleHandle == NULL) {
+            //
+            // Bail if any are missing.
+            //
+            DeclareError( INSTALER_MISSING_MODULE,
+                          GetLastError(),
+                          ModuleInfo[ ModuleIndex ].ModuleName
+                        );
+            return FALSE;
+            }
+        }
+
+    //
+    // Now loop over the table of entry points that we care about and
+    // get the address of each entry point from the
+
+    for (ApiIndex=0; ApiIndex<MAXIMUM_API_INDEX; ApiIndex++) {
+        ModuleIndex = ApiInfo[ ApiIndex ].ModuleIndex;
+
+        ApiInfo[ ApiIndex ].EntryPointAddress =
+            LookupEntryPointInIAT( ModuleInfo[ ModuleIndex ].ModuleHandle,
+                                   ApiInfo[ ApiIndex ].EntryPointName
+                                 );
+
+        if (ApiInfo[ ApiIndex ].EntryPointAddress == NULL) {
+            //
+            // Bail if we are unable to get the address of any of them
+            //
+            DeclareError( INSTALER_MISSING_ENTRYPOINT,
+                          GetLastError(),
+                          ApiInfo[ ApiIndex ].EntryPointName,
+                          ModuleInfo[ ModuleIndex ].ModuleName
+                        );
+            return FALSE;
+            }
+        }
+
+    CommandLine = NULL;
+    ProcessingDebugSwitch = FALSE;
+    AskUserOnce = FALSE;
+    while (--argc) {
+        s = *++argv;
+        if (*s == '-' || *s == '/') {
+            while (*++s) {
+                switch( tolower( *s ) ) {
+                    case '9':
+                        DefaultGetVersionToWin95 = TRUE;
+                        break;
+
+                    case 'r':
+                        FailAllScansOfRootDirectories = TRUE;
+                        break;
+#if TRACE_ENABLED
+                    case 'd':
+                        ProcessingDebugSwitch = TRUE;
+                        break;
+
+                    case 'a':
+                        if (ProcessingDebugSwitch) {
+                            EnabledTraceEvents = 0xFFFFFFFF;
+                            break;
+                            }
+                    case 'e':
+                        if (ProcessingDebugSwitch) {
+                            EnabledTraceEvents |= DBG_MASK_DBGEVENT;
+                            break;
+                            }
+                    case 'c':
+                        if (ProcessingDebugSwitch) {
+                            EnabledTraceEvents |= DBG_MASK_CREATEEVENT;
+                            break;
+                            }
+#endif
+                    default:
+                        if (!ProcessingDebugSwitch) {
+                            CommonSwitchProcessing( &argc, &argv, *s );
+                            }
+                        else {
+                            Usage( "Invalid debug switch (-%c)", (ULONG)*s );
+                            }
+                        break;
+                    }
+                }
+
+                ProcessingDebugSwitch = FALSE;
+            }
+        else
+        if (!CommonArgProcessing( &argc, &argv )) {
+            CommandLine = GetCommandLine();
+            while (*CommandLine && *CommandLine <= L' ') {
+                CommandLine += 1;
+                }
+
+            while (*CommandLine && *CommandLine > L' ') {
+                CommandLine += 1;
+                }
+
+            CommandLine = wcsstr( CommandLine, GetArgAsUnicode( s ) );
+            break;
+            }
+        }
+
+    if (ImlPath == NULL) {
+        Usage( "Must specify an installation name as first argument", 0 );
+        }
+
+    if (CommandLine == NULL) {
+        Usage( "Command line missing", 0 );
+        }
+
+    pImlNew = CreateIml( ImlPath, FALSE );
+    if (pImlNew == NULL) {
+        FatalError( "Unable to create %ws (%u)\n",
+                    (ULONG)ImlPath,
+                    GetLastError()
+                  );
+        }
+
+    //
+    // Ready to roll.  Cache the drive letter information and then load
+    // the application with the DEBUG option so we can watch what it does
+    //
+    if (!LoadDriveLetterDefinitions() ||
+        !LoadApplicationForDebug( CommandLine )
+       ) {
+        return FALSE;
+        }
+
+    return TRUE;
+}
+
+BOOLEAN
+LoadApplicationForDebug(
+    PWSTR CommandLine
+    )
+{
+    STARTUPINFO StartupInfo;
+    PROCESS_INFORMATION ProcessInformation;
+    PWSTR ImageFilePath;
+    PWSTR ImageFileName;
+    PWSTR CurrentDirectory;
+    PWSTR TemporaryNull;
+    WCHAR TemporaryChar;
+    ULONG Length;
+    WCHAR PathBuffer[ MAX_PATH ];
+
+    TemporaryNull = CommandLine;
+    while(TemporaryChar = *TemporaryNull) {
+        if (TemporaryChar == L' ' || TemporaryChar == L'\t') {
+            *TemporaryNull = UNICODE_NULL;
+            break;
+            }
+
+        TemporaryNull += 1;
+        }
+
+    ImageFilePath = AllocMem( MAX_PATH * sizeof( WCHAR ) );
+    Length = SearchPath( NULL,
+                         CommandLine,
+                         L".exe",
+                         MAX_PATH,
+                         ImageFilePath,
+                         &ImageFileName
+                       );
+    *TemporaryNull = TemporaryChar;
+    if (!Length || Length >= MAX_PATH) {
+        DeclareError( INSTALER_CANT_DEBUG_PROGRAM,
+                      GetLastError(),
+                      CommandLine
+                    );
+        return FALSE;
+        }
+
+    if (ImageFileName != NULL &&
+        ImageFileName > ImageFilePath &&
+        ImageFileName[ -1 ] == L'\\'
+       ) {
+        ImageFileName[ -1 ] = UNICODE_NULL;
+        CurrentDirectory = wcscpy( PathBuffer, ImageFilePath );
+        ImageFileName[ -1 ] = L'\\';
+        SetCurrentDirectory( CurrentDirectory );
+        }
+    else {
+        CurrentDirectory = NULL;
+        }
+
+    memset( &StartupInfo, 0, sizeof( StartupInfo ) );
+    StartupInfo.cb = sizeof(StartupInfo);
+
+    //
+    // Create the process with DEBUG option, as a separate WOW so we only see our
+    // application's damage.
+    //
+    if (!CreateProcess( ImageFilePath,
+                        CommandLine,
+                        NULL,
+                        NULL,
+                        FALSE,                          // No handles to inherit
+                        DEBUG_PROCESS |
+                          CREATE_SEPARATE_WOW_VDM,      // Ignored for 32 bit apps
+                        NULL,
+                        CurrentDirectory,
+                        &StartupInfo,
+                        &ProcessInformation
+                      )
+       ) {
+        DeclareError( INSTALER_CANT_DEBUG_PROGRAM,
+                      GetLastError(),
+                      CommandLine
+                    );
+        return FALSE;
+        }
+    else {
+        sprintf( (LPSTR)PathBuffer, "%ws%ws.log", InstalerDirectory, InstallationName );
+        InstalerLogFile = fopen( (LPSTR)PathBuffer, "w" );
+
+        //
+        // Will pick up the process and thread handles with the
+        // CREATE_PROCESS_DEBUG_EVENT and CREATE_PROCESS_THREAD_EVENT
+        //
+        return TRUE;
+        }
+}
+
+
+PVOID
+LookupEntryPointInIAT(
+    HMODULE ModuleHandle,
+    PCHAR EntryPointName
+    )
+{
+    PIMAGE_EXPORT_DIRECTORY Exports;
+    PIMAGE_RUNTIME_FUNCTION_ENTRY FunctionTableEntries;
+    DWORD NumberOfFunctionTableEntries;
+    ULONG ExportSize, FunctionTableSize;
+    PCHAR *EntryPointNames;
+    PULONG EntryPointAddresses;
+    PUSHORT EntryPointOrdinals;
+    PVOID EntryPointAddress;
+    ULONG i;
+
+    Exports = (PIMAGE_EXPORT_DIRECTORY)RtlImageDirectoryEntryToData( ModuleHandle,
+                                                                     TRUE,
+                                                                     IMAGE_DIRECTORY_ENTRY_EXPORT,
+                                                                     &ExportSize
+                                                                   );
+    if (Exports == NULL) {
+        return NULL;
+        }
+
+    FunctionTableEntries = (PIMAGE_RUNTIME_FUNCTION_ENTRY)
+        RtlImageDirectoryEntryToData( ModuleHandle,
+                                      TRUE,
+                                      IMAGE_DIRECTORY_ENTRY_EXCEPTION,
+                                      &FunctionTableSize
+                                    );
+    if (FunctionTableEntries != NULL) {
+        NumberOfFunctionTableEntries = FunctionTableSize / sizeof( IMAGE_RUNTIME_FUNCTION_ENTRY );
+        }
+    else {
+        NumberOfFunctionTableEntries = 0;
+        }
+
+    EntryPointNames = (PCHAR *)((PCHAR)ModuleHandle + (ULONG)Exports->AddressOfNames);
+    EntryPointOrdinals = (PUSHORT)((PCHAR)ModuleHandle + (ULONG)Exports->AddressOfNameOrdinals);
+    EntryPointAddresses = (PULONG)((PCHAR)ModuleHandle + (ULONG)Exports->AddressOfFunctions);
+    for (i=0; i<Exports->NumberOfNames; i++) {
+        EntryPointAddress = (PVOID)((PCHAR)ModuleHandle +
+                                    EntryPointAddresses[ EntryPointOrdinals[ i ] ]
+                                   );
+        if ((ULONG)EntryPointAddress > (ULONG)Exports &&
+             (ULONG)EntryPointAddress < ((ULONG)Exports + ExportSize)
+            ) {
+            //
+            // Skip this... It's a forwarded reference
+            }
+        else
+        if (!_stricmp( EntryPointName, (PCHAR)ModuleHandle + (ULONG)EntryPointNames[ i ] )) {
+            return GetAddressForEntryPointBreakpoint( EntryPointAddress,
+                                                      NumberOfFunctionTableEntries,
+                                                      FunctionTableEntries
+                                                    );
+            }
+        }
+
+    DbgEvent( INTERNALERROR, ( "Unable to find entry point '%s' in module at %x\n", EntryPointName, ModuleHandle ) );
+    return NULL;
+}
+
+
+PVOID
+GetAddressForEntryPointBreakpoint(
+    PVOID EntryPointAddress,
+    DWORD NumberOfFunctionTableEntries OPTIONAL,
+    PIMAGE_RUNTIME_FUNCTION_ENTRY FunctionTableEntries OPTIONAL
+    )
+{
+    PIMAGE_RUNTIME_FUNCTION_ENTRY FunctionEntry;
+    PIMAGE_RUNTIME_FUNCTION_ENTRY FunctionTable;
+    LONG High;
+    LONG Low;
+    LONG Middle;
+
+    //
+    // If no function table, then okay to set breakpoint at exported
+    // address.
+    //
+    if (NumberOfFunctionTableEntries == 0) {
+        return EntryPointAddress;
+        }
+
+    //
+    // Initialize search indicies.
+    //
+    Low = 0;
+    High = NumberOfFunctionTableEntries - 1;
+    FunctionTable = FunctionTableEntries;
+
+    //
+    // Perform binary search on the function table for a function table
+    // entry that subsumes the specified PC.
+    //
+    while (High >= Low) {
+        //
+        // Compute next probe index and test entry. If the specified PC
+        // is greater than of equal to the beginning address and less
+        // than the ending address of the function table entry, then
+        // return the address of the function table entry. Otherwise,
+        // continue the search.
+        //
+        Middle = (Low + High) >> 1;
+        FunctionEntry = &FunctionTable[Middle];
+        if ((ULONG)EntryPointAddress < FunctionEntry->BeginAddress) {
+            High = Middle - 1;
+            }
+        else
+        if ((ULONG)EntryPointAddress >= FunctionEntry->EndAddress) {
+            Low = Middle + 1;
+            }
+        else {
+            if (((ULONG)EntryPointAddress >= FunctionEntry->BeginAddress) &&
+                ((ULONG)EntryPointAddress < FunctionEntry->PrologEndAddress)) {
+                return (PVOID)FunctionEntry->PrologEndAddress;
+                }
+            else {
+                break;
+                }
+            }
+        }
+
+    //
+    // A function table entry for the specified PC was not found.  Just use
+    // the exported address and hope for the best.
+    //
+    return EntryPointAddress;
+}
+
+
+BOOLEAN
+LoadDriveLetterDefinitions( VOID )
+{
+    PVOID Buffer;
+    ULONG BufferSize;
+    ULONG cchDeviceName;
+    ULONG cch;
+    ULONG cchTargetPath;
+    PWSTR DeviceName;
+    PWSTR TargetPath;
+    ULONG DriveLetterIndex;
+    ULONG cb;
+    PDRIVE_LETTER_INFO p;
+
+    RtlInitUnicodeString( &AltDriveLetterPrefix, L"\\DosDevices\\" );
+    RtlInitUnicodeString( &DriveLetterPrefix, L"\\??\\" );
+    RtlInitUnicodeString( &UNCPrefix, L"UNC\\" );
+
+    BufferSize = 0x1000;
+    Buffer = VirtualAlloc( NULL, BufferSize, MEM_COMMIT, PAGE_READWRITE );
+    if (Buffer == NULL) {
+        DbgEvent( INTERNALERROR, ( "VirtualAlloc( %0x8 ) failed (%u)\n",
+                                   BufferSize,
+                                   GetLastError()
+                                 )
+                );
+
+        return FALSE;
+        }
+
+    cchTargetPath = BufferSize / sizeof( WCHAR );
+    cchDeviceName = QueryDosDeviceW( NULL,
+                                     Buffer,
+                                     cchTargetPath
+                                   );
+    if (cchDeviceName == 0) {
+        DbgEvent( INTERNALERROR, ( "QueryDosDeviceW( NULL ) failed (%u)\n",
+                                   GetLastError()
+                                 )
+                );
+        return FALSE;
+        }
+
+    cchTargetPath -= (cchDeviceName + 2);
+    DeviceName = Buffer;
+    TargetPath = DeviceName + 2 + cchDeviceName;
+    while (*DeviceName) {
+        if (wcslen( DeviceName ) == 2 &&
+            DeviceName[ 1 ] == L':' &&
+            _wcsupr( DeviceName ) &&
+            DeviceName[ 0 ] >= L'@' &&
+            DeviceName[ 0 ] <= L'_'
+           ) {
+            cch = QueryDosDeviceW( DeviceName, TargetPath, cchTargetPath );
+            if (cch == 0) {
+                DbgEvent( INTERNALERROR, ( "QueryDosDeviceW( %ws ) failed (%u)\n",
+                                           DeviceName,
+                                           GetLastError()
+                                         )
+                        );
+                return FALSE;
+                }
+
+            DriveLetterIndex = DeviceName[ 0 ] - L'@';
+            p = &DriveLetters[ DriveLetterIndex ];
+            p->DriveLetter = (WCHAR)(L'@' + DriveLetterIndex);
+            cb = (cch+1) * sizeof( WCHAR );
+            p->NtLinkTarget.Buffer = AllocMem( cb );
+            if (p->NtLinkTarget.Buffer == NULL) {
+                return FALSE;
+                }
+            MoveMemory( p->NtLinkTarget.Buffer, TargetPath, cb );
+            p->NtLinkTarget.Length = (USHORT)( cb - sizeof( WCHAR ));
+            p->NtLinkTarget.MaximumLength = (USHORT)cb;
+            p->DriveLetterValid = TRUE;
+            }
+
+        while (*DeviceName++)
+            ;
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+IsDriveLetterPath(
+    PUNICODE_STRING Path
+    )
+{
+    ULONG DriveLetterIndex;
+    PDRIVE_LETTER_INFO p;
+    PUNICODE_STRING Prefix;
+
+    if (RtlPrefixUnicodeString( Prefix = &DriveLetterPrefix, Path, TRUE ) ||
+        RtlPrefixUnicodeString( Prefix = &AltDriveLetterPrefix, Path, TRUE )
+       ) {
+        Path->Length -= Prefix->Length;
+        RtlMoveMemory( Path->Buffer,
+                       (PCHAR)(Path->Buffer) + Prefix->Length,
+                       Path->Length + sizeof( UNICODE_NULL )
+                     );
+        if (RtlPrefixUnicodeString( &UNCPrefix, Path, TRUE )) {
+            Path->Length -= UNCPrefix.Length;
+            Path->Buffer[0] = L'\\';
+            Path->Buffer[1] = L'\\';
+            RtlMoveMemory( &Path->Buffer[2],
+                           (PCHAR)(Path->Buffer) + UNCPrefix.Length,
+                           Path->Length + sizeof( UNICODE_NULL )
+                         );
+            Path->Length += 2 * sizeof( WCHAR );
+            }
+
+        return TRUE;
+        }
+
+    for (DriveLetterIndex=0, p = &DriveLetters[ DriveLetterIndex ];
+         DriveLetterIndex<32;
+         DriveLetterIndex++, p++
+        ) {
+        if (p->DriveLetterValid &&
+            RtlPrefixUnicodeString( &p->NtLinkTarget, Path, TRUE )
+           ) {
+            Path->Length -= p->NtLinkTarget.Length;
+            RtlMoveMemory( &Path->Buffer[ 2 ],
+                           (PCHAR)(Path->Buffer) + p->NtLinkTarget.Length,
+                           Path->Length + sizeof( UNICODE_NULL )
+                         );
+            Path->Buffer[ 0 ] = p->DriveLetter;
+            Path->Buffer[ 1 ] = L':';
+            Path->Length += 2;
+            return TRUE;
+            }
+        }
+
+    return FALSE;
+}
+
+
+
+VOID
+TrimTemporaryBuffer( VOID )
+{
+    PVOID CommitAddress;
+
+    if (TemporaryBufferLength == 0) {
+        return;
+        }
+
+    if (VirtualFree( (PCHAR)TemporaryBuffer,
+                     TemporaryBufferLength,
+                     MEM_DECOMMIT
+                   )
+       ) {
+        TemporaryBufferLength = 0;
+        }
+
+    return;
+}
+
+BOOLEAN
+GrowTemporaryBuffer(
+    ULONG NeededSize
+    )
+{
+    PVOID CommitAddress;
+
+    if (NeededSize <= TemporaryBufferLength) {
+        return TRUE;
+        }
+
+    if (TemporaryBufferLength == TemporaryBufferMaximumLength) {
+        return FALSE;
+        }
+
+    CommitAddress = VirtualAlloc( (PCHAR)TemporaryBuffer + TemporaryBufferLength,
+                                  NeededSize - TemporaryBufferLength,
+                                  MEM_COMMIT,
+                                  PAGE_READWRITE
+                                );
+    if (CommitAddress == NULL) {
+        DbgEvent( INTERNALERROR, ( "VirtualAlloc( %0x8 ) failed (%u)\n",
+                                   NeededSize - TemporaryBufferLength,
+                                   GetLastError()
+                                 )
+                );
+
+        return FALSE;
+        }
+
+    TemporaryBufferLength += TemporaryBufferLengthGrowth;
+    return TRUE;
+}
+
+ULONG
+FillTemporaryBuffer(
+    PPROCESS_INFO Process,
+    PVOID Address,
+    BOOLEAN Unicode,
+    BOOLEAN DoubleNullTermination
+    )
+{
+    ULONG BytesRead;
+    ULONG TotalBytesRead;
+    PVOID Source;
+    PVOID Destination;
+    LPSTR s1;
+    PWSTR s2;
+    BOOLEAN MoreToRead;
+    BOOLEAN SeenOneNull;
+
+    TotalBytesRead = 0;
+    Destination = (PCHAR)TemporaryBuffer;
+    MoreToRead = TRUE;
+    SeenOneNull = FALSE;
+    while (MoreToRead) {
+        TotalBytesRead += TemporaryBufferLengthGrowth;
+        if (!GrowTemporaryBuffer( TotalBytesRead )) {
+            return 0;
+            }
+
+        Source = Destination;
+        if (!ReadProcessMemory( Process->Handle,
+                                Address,
+                                Destination,
+                                TemporaryBufferLengthGrowth,
+                                &BytesRead
+                              )
+           ) {
+            if (BytesRead == 0) {
+                MoreToRead = FALSE;
+                }
+            else {
+                return 0;
+                }
+            }
+
+        Destination = (PCHAR)Destination + TotalBytesRead;
+        if (Unicode) {
+            s2 = (PWSTR)Source;
+            while (s2 < (PWSTR)Destination) {
+                if (*s2 == UNICODE_NULL) {
+                    if (SeenOneNull || !DoubleNullTermination) {
+                        return (PCHAR)s2 - (PCHAR)TemporaryBuffer;
+                        }
+                    else {
+                        SeenOneNull = TRUE;
+                        }
+                    }
+                else {
+                    SeenOneNull = FALSE;
+                    }
+
+                s2++;
+                }
+            }
+        else {
+            s1 = (LPSTR)Source;
+            while (s1 < (LPSTR)Destination) {
+                if (*s1 == '\0') {
+                    if (SeenOneNull || !DoubleNullTermination) {
+                        return (PCHAR)s1 - (PCHAR)TemporaryBuffer;
+                        }
+                    else {
+                        SeenOneNull = TRUE;
+                        }
+                    }
+                else {
+                    SeenOneNull = FALSE;
+                    }
+
+                s1++;
+                }
+            }
+        }
+
+    return 0;
+}
diff --git a/private/sdktools/instaler/instaler.c b/private/sdktools/instaler/instaler.c
new file mode 100644
index 000000000..e3b73297c
--- /dev/null
+++ b/private/sdktools/instaler/instaler.c
@@ -0,0 +1,159 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    instaler.c
+
+Abstract:
+
+    USAGE: instaler "setup/install command line"
+
+    Main source file for the INSTALER application.  This application is
+    intended for use as a wrapper application around another
+    application's setup/install program.  This program uses the Debugger
+    API calls to set breakpoints in the setup/install program and its
+    descendents at all calls to NT/Win32 API calls that modify the
+    current system.  The API calls that are tracked include:
+
+        NtCreateFile
+        NtDeleteFile
+        NtSetInformationFile (FileRenameInformation, FileDispositionInformation)
+        NtCreateKey
+        NtOpenKey
+        NtDeleteKey
+        NtSetValueKey
+        NtDeleteValueKey
+        GetVersion
+        GetVersionExW
+        WriteProfileStringA/W
+        WritePrivateProfileStringA/W
+        WriteProfileSectionA/W
+        WritePrivateProfileSectionA/W
+        RegConnectRegistryW
+
+    This program sets breakpoints around each of the above API entry
+    points.  At the breakpoint at the entry to an API call, the
+    parameters are inspected and if the call is going to overwrite some
+    state (e.g.  create/open a file/key for write access, store a new
+    key value or profile string), then this program will save the old
+    state in a temporary directory before letting the API call proceed.
+    At the exit from the API call, it will determine if the operation
+    was successful.  If not, the saved state will be discarded.  If
+    successful, it will keep the saved state for when the application
+    setup/install program completes.  Part of the Create/Open API
+    tracking is the maintenance of a handle database so that relative opens
+    can be handled correctly with the full path.
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+--*/
+
+#include "instaler.h"
+
+BOOLEAN
+SortReferenceList(
+    PLIST_ENTRY OldHead,
+    ULONG NumberOfEntriesInList
+    );
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    if (!InitializeInstaler( argc, argv )) {
+        ExitProcess( 1 );
+        }
+    else {
+        StartProcessTickCount = GetTickCount();
+        DebugEventLoop();
+        printf( "Creating %ws\n", ImlPath );
+        SortReferenceList( &FileReferenceListHead, NumberOfFileReferences );
+        SortReferenceList( &KeyReferenceListHead, NumberOfKeyReferences );
+        SortReferenceList( &IniReferenceListHead, NumberOfIniReferences );
+        DumpFileReferenceList( InstalerLogFile );
+        DumpKeyReferenceList( InstalerLogFile );
+        DumpIniFileReferenceList( InstalerLogFile );
+        DumpNameDataBase( InstalerLogFile );
+        CloseIml( pImlNew );
+        fclose( InstalerLogFile );
+        ExitProcess( 0 );
+        }
+
+    return 0;
+}
+
+
+typedef struct _GENERIC_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+} GENERIC_REFERENCE, *PGENERIC_REFERENCE;
+
+
+int
+_CRTAPI1
+CompareReferences(
+    const void *Reference1,
+    const void *Reference2
+    )
+{
+    PGENERIC_REFERENCE p1 = *(PGENERIC_REFERENCE *)Reference1;
+    PGENERIC_REFERENCE p2 = *(PGENERIC_REFERENCE *)Reference2;
+
+    return _wcsicmp( p1->Name, p2->Name );
+}
+
+
+BOOLEAN
+SortReferenceList(
+    PLIST_ENTRY Head,
+    ULONG NumberOfEntriesInList
+    )
+{
+    PGENERIC_REFERENCE p, *SortedArray;
+    PLIST_ENTRY Next;
+    ULONG i;
+
+    if (NumberOfEntriesInList == 0) {
+        return TRUE;
+        }
+
+    SortedArray = AllocMem( NumberOfEntriesInList * sizeof( *SortedArray ) );
+    if (SortedArray == NULL) {
+        return FALSE;
+        }
+
+    Next = Head->Flink;
+    i = 0;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, GENERIC_REFERENCE, Entry );
+        if (i >= NumberOfEntriesInList) {
+            break;
+            }
+
+        SortedArray[ i++ ] = p;
+        Next = Next->Flink;
+        }
+
+    qsort( (void *)SortedArray,
+           NumberOfEntriesInList,
+           sizeof( *SortedArray ),
+           CompareReferences
+         );
+
+    InitializeListHead( Head );
+    for (i=0; i<NumberOfEntriesInList; i++) {
+        p = SortedArray[ i ];
+        InsertTailList( Head, &p->Entry );
+        }
+
+    FreeMem( (PVOID *)&SortedArray );
+
+    return TRUE;
+}
diff --git a/private/sdktools/instaler/instaler.h b/private/sdktools/instaler/instaler.h
new file mode 100644
index 000000000..5ae44b683
--- /dev/null
+++ b/private/sdktools/instaler/instaler.h
@@ -0,0 +1,1165 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    instaler.h
+
+Abstract:
+
+    Main include file for the INSTALER application.
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+Revision History:
+
+--*/
+
+#ifdef RC_INVOKED
+#include <windows.h>
+
+#define FILEBMP  500
+#define DIRBMP   501
+
+#else
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <ntdbg.h>
+#include <windows.h>
+#include <vdmdbg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "errormsg.h"
+
+//
+// Data structures and entry points in ERROR.C
+//
+
+#define TRACE_ENABLED 1
+
+#if TRACE_ENABLED
+extern ULONG EnabledTraceEvents;
+
+#define DBG_MASK_DBGEVENT       0x00000001
+#define DBG_MASK_INTERNALERROR  0x00000002
+#define DBG_MASK_MEMORYERROR    0x00000004
+#define DBG_MASK_CREATEEVENT    0x00000008
+
+VOID
+TraceDisplay(
+    const char *FormatString,
+    ...
+    );
+
+#define DbgEvent( m, x ) if (EnabledTraceEvents & (DBG_MASK_##m)) TraceDisplay x
+#define TestDbgEvent( m ) (EnabledTraceEvents & (DBG_MASK_##m))
+#else
+#define DbgEvent( m, x )
+#define TestDbgEvent( m ) (FALSE)
+#endif
+
+
+VOID
+CDECL
+DeclareError(
+    UINT ErrorCode,
+    UINT SupplementalErrorCode,
+    ...
+    );
+
+UINT
+CDECL
+AskUser(
+    UINT MessageBoxFlags,
+    UINT MessageId,
+    UINT NumberOfArguments,
+    ...
+    );
+
+
+//
+// Data structures and entry points in EVENT.C
+//
+
+VOID
+CDECL
+LogEvent(
+    UINT MessageId,
+    UINT NumberOfArguments,
+    ...
+    );
+
+//
+// Data structures and entry points in PROCESS.C
+//
+
+#define HANDLE_TYPE_FILE 0
+#define HANDLE_TYPE_KEY 1
+#define HANDLE_TYPE_NONE 2
+
+typedef struct _OPENHANDLE_INFO {
+    LIST_ENTRY Entry;
+    HANDLE Handle;
+    BOOLEAN Inherit;
+    BOOLEAN RootDirectory;
+    USHORT Type;
+    USHORT LengthOfName;
+    PWSTR Name;
+
+    //
+    // Union for handlers that need to store state in a handle during
+    // use.
+    //
+    union {
+        PWSTR QueryName;
+    };
+} OPENHANDLE_INFO, *POPENHANDLE_INFO;
+
+typedef struct _PROCESS_INFO {
+    LIST_ENTRY Entry;
+    LIST_ENTRY ThreadListHead;
+    LIST_ENTRY BreakpointListHead;
+    LIST_ENTRY OpenHandleListHead;
+    DWORD Id;
+    HANDLE Handle;
+    PROCESS_BASIC_INFORMATION ProcessInformation;
+    WCHAR ImageFileName[ 32 ];
+} PROCESS_INFO, *PPROCESS_INFO;
+
+typedef struct _THREAD_INFO {
+    LIST_ENTRY Entry;
+    LIST_ENTRY BreakpointListHead;
+    DWORD Id;
+    HANDLE Handle;
+    PVOID StartAddress;
+    ULONG ModuleIndexCurrentlyIn;
+    BOOLEAN SingleStepExpected;
+    struct _BREAKPOINT_INFO *BreakpointToStepOver;
+} THREAD_INFO, *PTHREAD_INFO;
+
+LIST_ENTRY ProcessListHead;
+
+BOOLEAN
+AddProcess(
+    LPDEBUG_EVENT DebugEvent,
+    PPROCESS_INFO *ReturnedProcess
+    );
+
+BOOLEAN
+DeleteProcess(
+    PPROCESS_INFO Process
+    );
+
+BOOLEAN
+AddThread(
+    LPDEBUG_EVENT DebugEvent,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO *ReturnedThread
+    );
+
+BOOLEAN
+DeleteThread(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    );
+
+PPROCESS_INFO
+FindProcessById(
+    ULONG Id
+    );
+
+BOOLEAN
+FindProcessAndThreadForEvent(
+    LPDEBUG_EVENT DebugEvent,
+    PPROCESS_INFO *ReturnedProcess,
+    PTHREAD_INFO *ReturnedThread
+    );
+
+BOOLEAN
+HandleThreadsForSingleStep(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO ThreadToSingleStep,
+    BOOLEAN SuspendThreads
+    );
+
+BOOLEAN
+ReadMemory(
+    PPROCESS_INFO Process,
+    PVOID Address,
+    PVOID DataRead,
+    ULONG BytesToRead,
+    PCHAR Reason
+    );
+
+BOOLEAN
+WriteMemory(
+    PPROCESS_INFO Process,
+    PVOID Address,
+    PVOID DataToWrite,
+    ULONG BytesToWrite,
+    PCHAR Reason
+    );
+
+PVOID
+AllocMem(
+    ULONG Size
+    );
+
+VOID
+FreeMem(
+    PVOID *p
+    );
+
+
+//
+// Data structures and entry points in MACHINE.C
+//
+
+PVOID BreakpointInstruction;
+ULONG SizeofBreakpointInstruction;
+
+PVOID
+GetAddressForEntryPointBreakpoint(
+    PVOID EntryPointAddress,
+    DWORD NumberOfFunctionTableEntries OPTIONAL,
+    PIMAGE_RUNTIME_FUNCTION_ENTRY FunctionTableEntries OPTIONAL
+    );
+
+BOOLEAN
+SkipOverHardcodedBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PVOID BreakpointAddress
+    );
+
+BOOLEAN
+ExtractProcedureParameters(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PULONG ReturnAddress,
+    ULONG SizeOfParameters,
+    PULONG Parameters
+    );
+
+BOOLEAN
+ExtractProcedureReturnValue(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PVOID ReturnValue,
+    ULONG SizeOfReturnValue
+    );
+
+BOOLEAN
+SetProcedureReturnValue(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PVOID ReturnValue,
+    ULONG SizeOfReturnValue
+    );
+
+BOOLEAN
+ForceReturnToCaller(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    ULONG SizeOfParameters,
+    PVOID ReturnAddress,
+    PVOID ReturnValue,
+    ULONG SizeOfReturnValue
+    );
+
+BOOLEAN
+UndoReturnAddressBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    );
+
+BOOLEAN
+BeginSingleStepBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    );
+
+BOOLEAN
+EndSingleStepBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    );
+
+typedef enum _API_ACTION {
+    QueryPath,
+    OpenPath,
+    RenamePath,
+    DeletePath,
+    SetValue,
+    DeleteValue,
+    WriteIniValue,
+    WriteIniSection
+} API_ACTION;
+
+typedef struct _API_SAVED_CALL_STATE {
+    LIST_ENTRY Entry;
+    API_ACTION Action;
+    ULONG Type;
+    PWSTR FullName;
+    PVOID Reference;
+    union {
+        struct {
+            BOOLEAN InheritHandle;
+            BOOLEAN WriteAccessRequested;
+            PHANDLE ResultHandleAddress;
+        } PathOpen;
+        struct {
+            PWSTR NewName;
+            BOOLEAN ReplaceIfExists;
+        } PathRename;
+        struct {
+            PWSTR SectionName;
+            PWSTR VariableName;
+            PWSTR VariableValue;
+        } SetIniValue;
+        struct {
+            PWSTR SectionName;
+            PWSTR SectionValue;
+        } SetIniSection;
+    };
+} API_SAVED_CALL_STATE, *PAPI_SAVED_CALL_STATE;
+
+BOOLEAN
+CreateSavedCallState(
+    PPROCESS_INFO Process,
+    PAPI_SAVED_CALL_STATE SavedCallState,
+    API_ACTION Action,
+    ULONG Type,
+    PWSTR FullName,
+    ...
+    );
+
+VOID
+FreeSavedCallState(
+    PAPI_SAVED_CALL_STATE CallState
+    );
+
+
+
+//
+// Data structures and entry points in HANDLER.C
+//
+
+typedef struct _CREATEFILE_PARAMETERS {
+    PHANDLE FileHandle;
+    ACCESS_MASK DesiredAccess;
+    POBJECT_ATTRIBUTES ObjectAttributes;
+    PIO_STATUS_BLOCK IoStatusBlock;
+    PLARGE_INTEGER AllocationSize;
+    ULONG FileAttributes;
+    ULONG ShareAccess;
+    ULONG CreateDisposition;
+    ULONG CreateOptions;
+} CREATEFILE_PARAMETERS, *PCREATEFILE_PARAMETERS;
+
+typedef struct _OPENFILE_PARAMETERS {
+    PHANDLE FileHandle;
+    ACCESS_MASK DesiredAccess;
+    POBJECT_ATTRIBUTES ObjectAttributes;
+    PIO_STATUS_BLOCK IoStatusBlock;
+    ULONG ShareAccess;
+    ULONG OpenOptions;
+} OPENFILE_PARAMETERS, *POPENFILE_PARAMETERS;
+
+typedef struct _DELETEFILE_PARAMETERS {
+    POBJECT_ATTRIBUTES ObjectAttributes;
+} DELETEFILE_PARAMETERS, *PDELETEFILE_PARAMETERS;
+
+typedef struct _SETINFORMATIONFILE_PARAMETERS {
+    HANDLE FileHandle;
+    PIO_STATUS_BLOCK IoStatusBlock;
+    PVOID FileInformation;
+    ULONG Length;
+    FILE_INFORMATION_CLASS FileInformationClass;
+} SETINFORMATIONFILE_PARAMETERS, *PSETINFORMATIONFILE_PARAMETERS;
+
+typedef struct _QUERYATTRIBUTESFILE_PARAMETERS {
+    POBJECT_ATTRIBUTES ObjectAttributes;
+    PFILE_BASIC_INFORMATION FileInformation;
+} QUERYATTRIBUTESFILE_PARAMETERS, *PQUERYATTRIBUTESFILE_PARAMETERS;
+
+typedef struct _QUERYDIRECTORYFILE_PARAMETERS {
+    HANDLE FileHandle;
+    HANDLE Event;
+    PIO_APC_ROUTINE ApcRoutine;
+    PVOID ApcContext;
+    PIO_STATUS_BLOCK IoStatusBlock;
+    PVOID FileInformation;
+    ULONG Length;
+    FILE_INFORMATION_CLASS FileInformationClass;
+    BOOLEAN ReturnSingleEntry;
+    PUNICODE_STRING FileName;
+    BOOLEAN RestartScan;
+} QUERYDIRECTORYFILE_PARAMETERS, *PQUERYDIRECTORYFILE_PARAMETERS;
+
+typedef struct _CREATEKEY_PARAMETERS {
+    PHANDLE KeyHandle;
+    ACCESS_MASK DesiredAccess;
+    POBJECT_ATTRIBUTES ObjectAttributes;
+    ULONG TitleIndex;
+    PUNICODE_STRING Class;
+    ULONG CreateOptions;
+    PULONG Disposition;
+} CREATEKEY_PARAMETERS, *PCREATEKEY_PARAMETERS;
+
+typedef struct _OPENKEY_PARAMETERS {
+    PHANDLE KeyHandle;
+    ACCESS_MASK DesiredAccess;
+    POBJECT_ATTRIBUTES ObjectAttributes;
+} OPENKEY_PARAMETERS, *POPENKEY_PARAMETERS;
+
+typedef struct _DELETEKEY_PARAMETERS {
+    HANDLE KeyHandle;
+} DELETEKEY_PARAMETERS, *PDELETEKEY_PARAMETERS;
+
+typedef struct _SETVALUEKEY_PARAMETERS {
+    HANDLE KeyHandle;
+    PUNICODE_STRING ValueName;
+    ULONG TitleIndex;
+    ULONG Type;
+    PVOID Data;
+    ULONG DataLength;
+} SETVALUEKEY_PARAMETERS, *PSETVALUEKEY_PARAMETERS;
+
+typedef struct _DELETEVALUEKEY_PARAMETERS {
+    HANDLE KeyHandle;
+    PUNICODE_STRING ValueName;
+} DELETEVALUEKEY_PARAMETERS, *PDELETEVALUEKEY_PARAMETERS;
+
+typedef struct _CLOSEHANDLE_PARAMETERS {
+    HANDLE Handle;
+} CLOSEHANDLE_PARAMETERS, *PCLOSEHANDLE_PARAMETERS;
+
+typedef struct _GETVERSIONEXW_PARAMETERS {
+    LPOSVERSIONINFOA lpVersionInformation;
+} GETVERSIONEXW_PARAMETERS, *PGETVERSIONEXW_PARAMETERS;
+
+typedef struct _SETCURRENTDIRECTORYA_PARAMETERS {
+    LPSTR lpPathName;
+} SETCURRENTDIRECTORYA_PARAMETERS, *PSETCURRENTDIRECTORYA_PARAMETERS;
+
+typedef struct _SETCURRENTDIRECTORYW_PARAMETERS {
+    PWSTR lpPathName;
+} SETCURRENTDIRECTORYW_PARAMETERS, *PSETCURRENTDIRECTORYW_PARAMETERS;
+
+typedef struct _WRITEPRIVATEPROFILESTRINGA_PARAMETERS {
+    LPCSTR lpAppName;
+    LPCSTR lpKeyName;
+    LPCSTR lpString;
+    LPCSTR lpFileName;
+} WRITEPRIVATEPROFILESTRINGA_PARAMETERS, *PWRITEPRIVATEPROFILESTRINGA_PARAMETERS;
+
+typedef struct _WRITEPRIVATEPROFILESTRINGW_PARAMETERS {
+    LPCWSTR lpAppName;
+    LPCWSTR lpKeyName;
+    LPCWSTR lpString;
+    LPCWSTR lpFileName;
+} WRITEPRIVATEPROFILESTRINGW_PARAMETERS, *PWRITEPRIVATEPROFILESTRINGW_PARAMETERS;
+
+typedef struct _WRITEPRIVATEPROFILESECTIONA_PARAMETERS {
+    LPCSTR lpAppName;
+    LPCSTR lpString;
+    LPCSTR lpFileName;
+} WRITEPRIVATEPROFILESECTIONA_PARAMETERS, *PWRITEPRIVATEPROFILESECTIONA_PARAMETERS;
+
+typedef struct _WRITEPRIVATEPROFILESECTIONW_PARAMETERS {
+    LPCWSTR lpAppName;
+    LPCWSTR lpString;
+    LPCWSTR lpFileName;
+} WRITEPRIVATEPROFILESECTIONW_PARAMETERS, *PWRITEPRIVATEPROFILESECTIONW_PARAMETERS;
+
+typedef struct _REGCONNECTREGISTRYW_PARAMETERS {
+    LPWSTR lpMachineName;
+    HKEY hKey;
+    PHKEY phkResult;
+} REGCONNECTREGISTRYW_PARAMETERS, *PREGCONNECTREGISTRYW_PARAMETERS;
+
+typedef struct _API_SAVED_PARAMETERS {
+    API_SAVED_CALL_STATE SavedCallState;
+    union {
+        CREATEFILE_PARAMETERS CreateFile;
+        OPENFILE_PARAMETERS OpenFile;
+        DELETEFILE_PARAMETERS DeleteFile;
+        SETINFORMATIONFILE_PARAMETERS SetInformationFile;
+        QUERYATTRIBUTESFILE_PARAMETERS QueryAttributesFile;
+        QUERYDIRECTORYFILE_PARAMETERS QueryDirectoryFile;
+        CREATEKEY_PARAMETERS CreateKey;
+        OPENKEY_PARAMETERS OpenKey;
+        DELETEKEY_PARAMETERS DeleteKey;
+        SETVALUEKEY_PARAMETERS SetValueKey;
+        DELETEVALUEKEY_PARAMETERS DeleteValueKey;
+        CLOSEHANDLE_PARAMETERS CloseHandle;
+        GETVERSIONEXW_PARAMETERS GetVersionExW;
+        SETCURRENTDIRECTORYA_PARAMETERS SetCurrentDirectoryA;
+        SETCURRENTDIRECTORYW_PARAMETERS SetCurrentDirectoryW;
+        WRITEPRIVATEPROFILESTRINGA_PARAMETERS WritePrivateProfileStringA;
+        WRITEPRIVATEPROFILESTRINGW_PARAMETERS WritePrivateProfileStringW;
+        WRITEPRIVATEPROFILESECTIONA_PARAMETERS WritePrivateProfileSectionA;
+        WRITEPRIVATEPROFILESECTIONW_PARAMETERS WritePrivateProfileSectionW;
+        REGCONNECTREGISTRYW_PARAMETERS RegConnectRegistryW;
+    } InputParameters;
+    PVOID ReturnAddress;
+    union {
+        UCHAR ReturnedByte;
+        USHORT ReturnedShort;
+        ULONG ReturnedLong;
+        ULONGLONG ReturnedQuad;
+        BOOL ReturnedBool;
+    } ReturnValue;
+    BOOLEAN ReturnValueValid;
+
+    //
+    // Union for handlers that need to store state between entry and
+    // exit, without the overhead of allocating an API_SAVED_CALL_STATE
+    //
+    union {
+        BOOLEAN AbortCall;
+        PWSTR CurrentDirectory;
+    };
+} API_SAVED_PARAMETERS, *PAPI_SAVED_PARAMETERS;
+
+BOOLEAN
+NtCreateFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtOpenFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtDeleteFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtSetInformationFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtQueryAttributesFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtQueryDirectoryFileHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtCreateKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtOpenKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtDeleteKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtSetValueKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+NtDeleteValueKeyHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+
+BOOLEAN
+NtCloseHandleHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+GetVersionHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+GetVersionExWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+SetCurrentDirectoryAHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+SetCurrentDirectoryWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+WritePrivateProfileStringAHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+WritePrivateProfileStringWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+WritePrivateProfileSectionAHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+WritePrivateProfileSectionWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+BOOLEAN
+RegConnectRegistryWHandler(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+//
+// Data structures and entry points in DEBUG.C
+//
+
+CRITICAL_SECTION BreakTable;
+
+typedef struct _BREAKPOINT_INFO {
+    LIST_ENTRY Entry;
+    PVOID Address;
+    UCHAR ApiIndex;
+    PWSTR ModuleName;
+    LPSTR ProcedureName;
+    BOOLEAN SavedInstructionValid;
+    BOOLEAN SavedParametersValid;
+    union {
+        UCHAR Byte;
+        USHORT Short;
+        ULONG Long;
+        ULONGLONG LongLong;
+    } SavedInstruction;
+    API_SAVED_PARAMETERS SavedParameters;
+} BREAKPOINT_INFO, *PBREAKPOINT_INFO;
+
+VOID
+DebugEventLoop( VOID );
+
+
+BOOLEAN
+InstallBreakpoint(
+    PPROCESS_INFO Process,
+    PBREAKPOINT_INFO Breakpoint
+    );
+
+BOOLEAN
+RemoveBreakpoint(
+    PPROCESS_INFO Process,
+    PBREAKPOINT_INFO Breakpoint
+    );
+
+BOOLEAN
+HandleBreakpoint(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PBREAKPOINT_INFO Breakpoint
+    );
+
+
+BOOLEAN
+CreateBreakpoint(
+    PVOID Address,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    UCHAR ApiIndex,
+    PVOID SavedParameters,
+    PBREAKPOINT_INFO *Breakpoint
+    );
+
+BOOLEAN
+DestroyBreakpoint(
+    PVOID Address,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    );
+
+PBREAKPOINT_INFO
+FindBreakpoint(
+    PVOID Address,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    );
+
+//
+// Data structures and entry points in HANDLEDB.C
+//
+
+POPENHANDLE_INFO
+FindOpenHandle(
+    PPROCESS_INFO Process,
+    HANDLE Handle,
+    ULONG Type
+    );
+
+BOOLEAN
+AddOpenHandle(
+    PPROCESS_INFO Process,
+    HANDLE Handle,
+    ULONG Type,
+    PWSTR Name,
+    BOOLEAN InheritHandle
+    );
+
+BOOLEAN
+DeleteOpenHandle(
+    PPROCESS_INFO Process,
+    HANDLE Handle,
+    ULONG Type
+    );
+
+VOID
+InheritHandles(
+    PPROCESS_INFO Process
+    );
+
+
+
+//
+// Data structures and entry points in FILE.C
+//
+
+
+typedef struct _FILE_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+    ULONG PrefixLength;
+    BOOLEAN WriteAccess;
+    BOOLEAN Deleted;
+    BOOLEAN Created;
+    BOOLEAN AttributesModified;
+    BOOLEAN DateModified;
+    BOOLEAN ContentsModified;
+    BOOLEAN DirectoryFile;
+    USHORT BackupFileUniqueId;
+    DWORD BackupFileAttributes;
+    FILETIME BackupLastWriteTime;
+    ULARGE_INTEGER BackupFileSize;
+} FILE_REFERENCE, *PFILE_REFERENCE;
+
+
+BOOLEAN
+CreateFileReference(
+    PWSTR Name,
+    BOOLEAN WriteAccess,
+    PFILE_REFERENCE *ReturnedReference
+    );
+
+BOOLEAN
+CompleteFileReference(
+    PFILE_REFERENCE p,
+    BOOLEAN CallSuccessful,
+    BOOLEAN Delete,
+    PFILE_REFERENCE RenameReference
+    );
+
+BOOLEAN
+DestroyFileReference(
+    PFILE_REFERENCE p
+    );
+
+BOOLEAN
+IsNewFileSameAsBackup(
+    PFILE_REFERENCE p
+    );
+
+PFILE_REFERENCE
+FindFileReference(
+    PWSTR Name
+    );
+
+VOID
+DumpFileReferenceList(
+    FILE *LogFile
+    );
+
+//
+// Data structures and entry points in KEY.C
+//
+
+typedef struct _KEY_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+    ULONG PrefixLength;
+    BOOLEAN WriteAccess;
+    BOOLEAN Deleted;
+    BOOLEAN Created;
+    PKEY_FULL_INFORMATION BackupKeyInfo;
+    LIST_ENTRY ValueReferencesListHead;
+} KEY_REFERENCE, *PKEY_REFERENCE;
+
+typedef struct _VALUE_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+    BOOLEAN Modified;
+    BOOLEAN Deleted;
+    BOOLEAN Created;
+    PKEY_VALUE_PARTIAL_INFORMATION Value;
+    KEY_VALUE_PARTIAL_INFORMATION OriginalValue;
+} VALUE_REFERENCE, *PVALUE_REFERENCE;
+
+BOOLEAN
+CreateKeyReference(
+    PWSTR Name,
+    BOOLEAN WriteAccess,
+    PKEY_REFERENCE *ReturnedReference
+    );
+
+BOOLEAN
+CompleteKeyReference(
+    PKEY_REFERENCE p,
+    BOOLEAN CallSuccessful,
+    BOOLEAN Delete
+    );
+
+BOOLEAN
+DestroyKeyReference(
+    PKEY_REFERENCE p
+    );
+
+PKEY_REFERENCE
+FindKeyReference(
+    PWSTR Name
+    );
+
+VOID
+MarkKeyDeleted(
+    PKEY_REFERENCE KeyReference
+    );
+
+BOOLEAN
+CreateValueReference(
+    PPROCESS_INFO Process,
+    PKEY_REFERENCE KeyReference,
+    PWSTR Name,
+    ULONG TitleIndex,
+    ULONG Type,
+    PVOID Data,
+    ULONG DataLength,
+    PVALUE_REFERENCE *ReturnedValueReference
+    );
+
+PVALUE_REFERENCE
+FindValueReference(
+    PKEY_REFERENCE KeyReference,
+    PWSTR Name
+    );
+
+BOOLEAN
+DestroyValueReference(
+    PVALUE_REFERENCE p
+    );
+
+VOID
+DumpKeyReferenceList(
+    FILE *LogFile
+    );
+
+//
+// Data structures and entry points in INI.C
+//
+
+typedef struct _INI_FILE_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+    ULONG PrefixLength;
+    BOOLEAN Created;
+    FILETIME BackupLastWriteTime;
+    LIST_ENTRY SectionReferencesListHead;
+} INI_FILE_REFERENCE, *PINI_FILE_REFERENCE;
+
+typedef struct _INI_SECTION_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+    BOOLEAN Deleted;
+    BOOLEAN Created;
+    LIST_ENTRY VariableReferencesListHead;
+} INI_SECTION_REFERENCE, *PINI_SECTION_REFERENCE;
+
+typedef struct _INI_VARIABLE_REFERENCE {
+    LIST_ENTRY Entry;
+    PWSTR Name;
+    BOOLEAN Modified;
+    BOOLEAN Deleted;
+    BOOLEAN Created;
+    PWSTR OriginalValue;
+    PWSTR Value;
+} INI_VARIABLE_REFERENCE, *PINI_VARIABLE_REFERENCE;
+
+
+BOOLEAN
+CreateIniFileReference(
+    PWSTR Name,
+    PINI_FILE_REFERENCE *ReturnedReference
+    );
+
+BOOLEAN
+DestroyIniFileReference(
+    PINI_FILE_REFERENCE p
+    );
+
+BOOLEAN
+DestroyIniSectionReference(
+    PINI_SECTION_REFERENCE p1
+    );
+
+BOOLEAN
+DestroyIniVariableReference(
+    PINI_VARIABLE_REFERENCE p2
+    );
+
+PINI_FILE_REFERENCE
+FindIniFileReference(
+    PWSTR Name
+    );
+
+PINI_SECTION_REFERENCE
+FindIniSectionReference(
+    PINI_FILE_REFERENCE p,
+    PWSTR Name,
+    BOOLEAN CreateOkay
+    );
+
+PINI_VARIABLE_REFERENCE
+FindIniVariableReference(
+    PINI_SECTION_REFERENCE p1,
+    PWSTR Name,
+    BOOLEAN CreateOkay
+    );
+
+VOID
+DumpIniFileReferenceList(
+    FILE *LogFile
+    );
+
+//
+// Data structures and entry points in NAMEDB.C
+//
+
+PWSTR
+AddName(
+    PUNICODE_STRING Name
+    );
+
+VOID
+DumpNameDataBase(
+    FILE *LogFile
+    );
+
+BOOLEAN
+IncrementOpenCount(
+    PWSTR Name,
+    BOOLEAN CallSuccessful
+    );
+
+ULONG
+QueryOpenCount(
+    PWSTR Name,
+    BOOLEAN CallSuccessful
+    );
+
+
+
+//
+// Data structures and entry points in INIT.C
+//
+
+HMODULE InstalerModuleHandle;
+HANDLE AppHeap;
+UNICODE_STRING WindowsDirectory;
+ULONG StartProcessTickCount;
+FILE *InstalerLogFile;
+BOOLEAN AskUserOnce;
+BOOLEAN DefaultGetVersionToWin95;
+BOOLEAN FailAllScansOfRootDirectories;
+
+
+
+LIST_ENTRY FileReferenceListHead;
+ULONG NumberOfFileReferences;
+LIST_ENTRY KeyReferenceListHead;
+ULONG NumberOfKeyReferences;
+LIST_ENTRY IniReferenceListHead;
+ULONG NumberOfIniReferences;
+
+#define NTDLL_MODULE_INDEX 0
+#define KERNEL32_MODULE_INDEX 1
+#define ADVAPI32_MODULE_INDEX 2
+#define MAXIMUM_MODULE_INDEX 3
+
+typedef struct _MODULE_INFO {
+    PWSTR ModuleName;
+    HMODULE ModuleHandle;
+} MODULE_INFO, *PMODULE_INFO;
+
+MODULE_INFO ModuleInfo[ MAXIMUM_MODULE_INDEX ];
+
+typedef BOOLEAN (*PAPI_HANDLER)(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    PAPI_SAVED_PARAMETERS Parameters
+    );
+
+typedef struct _API_INFO {
+    ULONG ModuleIndex;
+    LPSTR EntryPointName;                   // Exported names are ANSI only
+    PVOID EntryPointAddress;
+    PAPI_HANDLER EntryPointHandler;
+    ULONG SizeOfParameters;
+    ULONG SizeOfReturnValue;
+} API_INFO, *PAPI_INFO;
+
+#define NTCREATEFILE_INDEX                  0
+#define NTOPENFILE_INDEX                    1
+#define NTDELETEFILE_INDEX                  2
+#define NTSETINFORMATIONFILE_INDEX          3
+#define NTQUERYATTRIBUTESFILE_INDEX         4
+#define NTQUERYDIRECTORYFILE_INDEX          5
+#define NTCREATEKEY_INDEX                   6
+#define NTOPENKEY_INDEX                     7
+#define NTDELETEKEY_INDEX                   8
+#define NTSETVALUEKEY_INDEX                 9
+#define NTDELETEVALUEKEY_INDEX              10
+#define NTCLOSEHANDLE_INDEX                 11
+#define GETVERSION_INDEX                    12
+#define GETVERSIONEXW_INDEX                 13
+#define SETCURRENTDIRECTORYA_INDEX          14
+#define SETCURRENTDIRECTORYW_INDEX          15
+#define WRITEPRIVATEPROFILESTRINGA_INDEX    16
+#define WRITEPRIVATEPROFILESTRINGW_INDEX    17
+#define WRITEPRIVATEPROFILESECTIONA_INDEX   18
+#define WRITEPRIVATEPROFILESECTIONW_INDEX   19
+#define GETPRIVATEPROFILESTRINGA_INDEX      20
+#define GETPRIVATEPROFILESTRINGW_INDEX      21
+#define GETPRIVATEPROFILESECTIONA_INDEX     22
+#define GETPRIVATEPROFILESECTIONW_INDEX     23
+#define REGCONNECTREGISTRYW_INDEX           24
+#define MAXIMUM_API_INDEX                   25
+
+API_INFO ApiInfo[ MAXIMUM_API_INDEX ];
+
+typedef struct _DRIVE_LETTER_INFO {
+    WCHAR DriveLetter;
+    BOOLEAN DriveLetterValid;
+    UNICODE_STRING NtLinkTarget;
+} DRIVE_LETTER_INFO, *PDRIVE_LETTER_INFO;
+
+UNICODE_STRING UNCPrefix;
+UNICODE_STRING DriveLetterPrefix;
+UNICODE_STRING AltDriveLetterPrefix;
+DRIVE_LETTER_INFO DriveLetters[ 32 ];
+
+BOOLEAN
+InitializeInstaler(
+    int argc,
+    char *argv[]
+    );
+
+PVOID
+LookupEntryPointInIAT(
+    HMODULE ModuleHandle,
+    PCHAR EntryPointName
+    );
+
+BOOLEAN
+IsDriveLetterPath(
+    PUNICODE_STRING Path
+    );
+
+
+PVOID TemporaryBuffer;
+ULONG TemporaryBufferLength;
+ULONG TemporaryBufferLengthGrowth;
+ULONG TemporaryBufferMaximumLength;
+
+VOID
+TrimTemporaryBuffer( VOID );
+
+BOOLEAN
+GrowTemporaryBuffer(
+    ULONG NeededSize
+    );
+
+ULONG
+FillTemporaryBuffer(
+    PPROCESS_INFO Process,
+    PVOID Address,
+    BOOLEAN Unicode,
+    BOOLEAN DoubleNullTermination
+    );
+
+#include "instutil.h"
+#include "iml.h"
+
+PINSTALLATION_MODIFICATION_LOGFILE pImlNew;
+
+
+#endif // defined( RC_INVOKED )
diff --git a/private/sdktools/instaler/instaler.rc b/private/sdktools/instaler/instaler.rc
new file mode 100644
index 000000000..c608ba1aa
--- /dev/null
+++ b/private/sdktools/instaler/instaler.rc
@@ -0,0 +1,12 @@
+#include "instaler.h"
+#include <ntverp.h>
+
+#define	VER_FILETYPE	VFT_APP
+#define	VER_FILESUBTYPE	VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "Windows NT Instaler Program"
+#define VER_INTERNALNAME_STR        "INSTALER\0"
+#define VER_ORIGINALFILENAME_STR    "INSTALER.EXE"
+
+#include "common.ver"
+
+RCINCLUDE errormsg.rc
diff --git a/private/sdktools/instaler/instutil.c b/private/sdktools/instaler/instutil.c
new file mode 100644
index 000000000..fb9b0c683
--- /dev/null
+++ b/private/sdktools/instaler/instutil.c
@@ -0,0 +1,365 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    instutil.c
+
+Abstract:
+
+    Common code for INSTALER.EXE, DISPINST.EXE, COMPINST.EXE and UNDOINST.EXE
+
+Author:
+
+    Steve Wood (stevewo) 14-Jan-1996
+
+Revision History:
+
+--*/
+
+#include "instutil.h"
+#include "iml.h"
+
+LPSTR SavedModuleName;
+LPSTR SavedModuleUsage1;
+LPSTR SavedModuleUsage2;
+
+WCHAR AltTempFilePathBuffer[ MAX_PATH ];
+PWSTR AltTempFilePathFileName;
+WCHAR TempFilePathBuffer[ MAX_PATH ];
+PWSTR TempFilePathFileName;
+USHORT TempFileNextUniqueId;
+
+BOOL WINAPI
+CtrlCHandler(
+    ULONG CtrlType
+    )
+{
+    //
+    // Ignore control C interrupts.  Let child process deal with them
+    // if it wants.  If it doesn't then it will terminate and we will
+    // get control and terminate ourselves
+    //
+
+    return TRUE;
+}
+
+void
+InitCommonCode(
+    LPSTR ModuleName,
+    LPSTR ModuleUsage1,
+    LPSTR ModuleUsage2
+    )
+{
+    SavedModuleName = ModuleName;
+    SavedModuleUsage1 = ModuleUsage1;
+    SavedModuleUsage2 = ModuleUsage2;
+
+    GetTempPath( sizeof( TempFilePathBuffer ) / sizeof( WCHAR ),
+                 TempFilePathBuffer
+               );
+    TempFilePathFileName = TempFilePathBuffer + wcslen( TempFilePathBuffer );
+    TempFileNextUniqueId = (USHORT)0x0001;
+
+    InstalerDirectory[ 0 ] = UNICODE_NULL;
+    return;
+}
+
+void
+DisplayIndentedString(
+    ULONG IndentAmount,
+    PCHAR sBegin
+    )
+{
+    PCHAR sEnd;
+
+    while (sBegin != NULL) {
+        sEnd = sBegin;
+        while (*sEnd && *sEnd != '\n') {
+            sEnd += 1;
+            }
+
+        fprintf( stderr, "%.*s%.*s\n",
+                 IndentAmount,
+                 "                                                      ",
+                 sEnd - sBegin, sBegin
+               );
+
+        if (*sEnd == '\0') {
+            break;
+            }
+        else {
+            sBegin = ++sEnd;
+            }
+        }
+    return;
+}
+
+
+void
+Usage(
+    LPSTR Message,
+    ULONG MessageParameter
+    )
+{
+    ULONG n;
+    LPSTR sBegin, sEnd;
+
+    n = fprintf( stderr, "usage: %s ", SavedModuleName );
+    fprintf( stderr, "InstallationName\n" );
+    DisplayIndentedString( n, SavedModuleUsage1 );
+    fprintf( stderr, "\n" );
+
+    n = fprintf( stderr, "where: " );
+    fprintf( stderr, "InstallationName specifies a name for the installation.  This is a required parameter.\n" );
+    DisplayIndentedString( n,
+                           "-? Displays this message."
+                         );
+    fprintf( stderr, "\n" );
+    DisplayIndentedString( n, SavedModuleUsage2 );
+
+    if (Message != NULL) {
+        fprintf( stderr, "\n" );
+        }
+
+    //
+    // No return from FatalError
+    //
+    FatalError( Message, MessageParameter, 0 );
+}
+
+void
+FatalError(
+    LPSTR Message,
+    ULONG MessageParameter1,
+    ULONG MessageParameter2
+    )
+{
+    if (Message != NULL) {
+        fprintf( stderr, "%s: ", SavedModuleName );
+        fprintf( stderr, Message, MessageParameter1, MessageParameter2 );
+        fprintf( stderr, "\n" );
+        }
+
+    exit( 1 );
+}
+
+
+PWSTR
+GetArgAsUnicode(
+    LPSTR s
+    )
+{
+    ULONG n;
+    PWSTR ps;
+
+    n = strlen( s );
+    ps = HeapAlloc( GetProcessHeap(),
+                    0,
+                    (n + 1) * sizeof( WCHAR )
+                  );
+    if (ps == NULL) {
+        FatalError( "Out of memory", 0, 0 );
+        }
+
+    if (MultiByteToWideChar( CP_ACP,
+                             MB_PRECOMPOSED,
+                             s,
+                             n,
+                             ps,
+                             n
+                           ) != (LONG)n
+       ) {
+        FatalError( "Unable to convert parameter '%s' to Unicode (%u)", (ULONG)s, GetLastError() );
+        }
+
+    ps[ n ] = UNICODE_NULL;
+    return ps;
+}
+
+
+void
+CommonSwitchProcessing(
+    PULONG argc,
+    PCHAR **argv,
+    CHAR c
+    )
+{
+    DWORD dwFileAttributes;
+    PWSTR s;
+
+    switch( c = tolower( c ) ) {
+        case 'd':
+            DebugOutput = TRUE;
+            break;
+
+        case '?':
+            Usage( NULL, 0 );
+            break;
+
+        default:
+            Usage( "Invalid switch (-%c)", (ULONG)c );
+            break;
+        }
+
+    return;
+}
+
+
+BOOLEAN
+CommonArgProcessing(
+    PULONG argc,
+    PCHAR **argv
+    )
+{
+    PWSTR s;
+
+    if (InstallationName == NULL) {
+        GetCurrentDirectory( MAX_PATH, InstalerDirectory );
+        s = wcschr( InstalerDirectory, UNICODE_NULL );
+        if (s[-1] != L'\\') {
+            *s++ = L'\\';
+            *s = UNICODE_NULL;
+            }
+
+        InstallationName = GetArgAsUnicode( **argv );
+        ImlPath = FormatImlPath( InstalerDirectory, InstallationName );
+        return TRUE;
+        }
+    else {
+        return FALSE;
+        }
+}
+
+PWSTR
+FormatTempFileName(
+    PWSTR Directory,
+    PUSHORT TempFileUniqueId
+    )
+{
+    if (*TempFileUniqueId == 0) {
+        *TempFileUniqueId = (USHORT)(TempFileNextUniqueId++);
+        if (TempFileNextUniqueId == 0) {
+            return NULL;
+            }
+        }
+    else
+    if (*TempFileUniqueId == 0xFFFF) {
+        return NULL;
+        }
+
+    if (Directory != NULL) {
+        GetFullPathName( Directory, MAX_PATH, AltTempFilePathBuffer, &AltTempFilePathFileName );
+        AltTempFilePathFileName = wcsrchr( AltTempFilePathBuffer, TEXT('\\') );
+        AltTempFilePathFileName += 1;
+        swprintf( AltTempFilePathFileName, L"~INS%04x.TMP", *TempFileUniqueId );
+        return AltTempFilePathBuffer;
+        }
+    else {
+        swprintf( TempFilePathFileName, L"~INS%04x.TMP", *TempFileUniqueId );
+        return TempFilePathBuffer;
+        }
+}
+
+PWSTR
+CreateBackupFileName(
+    PUSHORT TempFileUniqueId
+    )
+{
+    PWSTR BackupFileName;
+
+    while (BackupFileName = FormatTempFileName( NULL, TempFileUniqueId )) {
+        if (GetFileAttributesW( BackupFileName ) == 0xFFFFFFFF) {
+            break;
+            }
+        else {
+            *TempFileUniqueId = 0;      // Temp file name existed, try next unique id
+            }
+        }
+
+    return BackupFileName;
+}
+
+
+UCHAR EnumTypeBuffer0[ 512 ];
+UCHAR EnumTypeBuffer1[ 512 ];
+UCHAR EnumTypeBuffer2[ 512 ];
+UCHAR EnumTypeBuffer3[ 512 ];
+LPSTR EnumTypeBuffers[ 4 ] = {
+    EnumTypeBuffer0,
+    EnumTypeBuffer1,
+    EnumTypeBuffer2,
+    EnumTypeBuffer3
+};
+
+LPSTR
+FormatEnumType(
+    ULONG BufferIndex,
+    PENUM_TYPE_NAMES Table,
+    ULONG Value,
+    BOOLEAN FlagFormat
+    )
+{
+    LPSTR s, FlagsBuffer = EnumTypeBuffers[ BufferIndex ];
+
+    FlagsBuffer[ 0 ] = '\0';
+    while (Table->Value != 0xFFFFFFFF) {
+        if (FlagFormat) {
+            if (Table->Value & Value) {
+                if (FlagsBuffer[ 0 ] != '\0') {
+                    strcat( FlagsBuffer, " | " );
+                    }
+
+                strcat( FlagsBuffer, Table->Name );
+                Value &= ~Table->Value;
+                if (Value == 0) {
+                    return FlagsBuffer;
+                    }
+                }
+            }
+        else
+        if (Table->Value == Value) {
+            if (Value == 0) {
+                if (!strcmp( Table->Name, "STATUS_WAIT_0" )) {
+                    return "STATUS_SUCCESS";
+                    }
+                else
+                if (!strcmp( Table->Name, "ERROR_SUCCESS" )) {
+                    return "NO_ERROR";
+                    }
+                }
+            return Table->Name;
+            }
+
+        Table += 1;
+        }
+
+    s = FlagsBuffer;
+    if (FlagFormat) {
+        if (s[ 0 ] != '\0') {
+            strcat( s, " | " );
+            s += strlen( s );
+            }
+        }
+
+    sprintf( s, Table->Name ? Table->Name : "%x", Value );
+    return FlagsBuffer;
+}
+
+
+
+ENUM_TYPE_NAMES ValueDataTypeNames[] = {
+    REG_NONE,                      "REG_NONE",
+    REG_SZ,                        "REG_SZ",
+    REG_EXPAND_SZ,                 "REG_EXPAND_SZ",
+    REG_BINARY,                    "REG_BINARY",
+    REG_DWORD,                     "REG_DWORD",
+    REG_DWORD_BIG_ENDIAN,          "REG_DWORD_BIG_ENDIAN",
+    REG_LINK,                      "REG_LINK",
+    REG_MULTI_SZ,                  "REG_MULTI_SZ",
+    REG_RESOURCE_LIST,             "REG_RESOURCE_LIST",
+    REG_FULL_RESOURCE_DESCRIPTOR,  "REG_FULL_RESOURCE_DESCRIPTOR",
+    REG_RESOURCE_REQUIREMENTS_LIST,"REG_RESOURCE_REQUIREMENTS_LIST",
+    0xFFFFFFFF,                     "%x"
+};
diff --git a/private/sdktools/instaler/instutil.h b/private/sdktools/instaler/instutil.h
new file mode 100644
index 000000000..1b98ddc51
--- /dev/null
+++ b/private/sdktools/instaler/instutil.h
@@ -0,0 +1,114 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    instutil.h
+
+Abstract:
+
+    Header file for common definition for programs that manipulate the output of
+    the INSTALER.EXE program (e.g. DISPINST.EXE, COMPINST.EXE, UNDOINST.EXE)
+
+Author:
+
+    Steve Wood (stevewo) 14-Jan-1996
+
+Revision History:
+
+--*/
+
+#include <windows.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <tchar.h>
+
+WCHAR InstalerDirectory[ MAX_PATH ];
+PWSTR InstallationName;
+PWSTR ImlPath;
+BOOLEAN DebugOutput;
+
+//
+// Useful rounding macros that the rounding amount is always a
+// power of two.
+//
+
+#define ROUND_DOWN( Size, Amount ) ((DWORD)(Size) & ~((Amount) - 1))
+#define ROUND_UP( Size, Amount ) (((DWORD)(Size) + ((Amount) - 1)) & ~((Amount) - 1))
+
+void
+InitCommonCode(
+    LPSTR ModuleName,
+    LPSTR ModuleUsage1,
+    LPSTR ModuleUsage2
+    );
+
+void
+Usage(
+    LPSTR Message,
+    ULONG MessageParameter
+    );
+
+void
+FatalError(
+    LPSTR Message,
+    ULONG MessageParameter1,
+    ULONG MessageParameter2
+    );
+
+void
+InputMessage(
+    PWSTR FileName,
+    ULONG LineNumber,
+    BOOLEAN Error,
+    LPSTR Message,
+    ULONG MessageParameter1,
+    ULONG MessageParameter2
+    );
+
+PWSTR
+GetArgAsUnicode(
+    LPSTR s
+    );
+
+void
+CommonSwitchProcessing(
+    PULONG argc,
+    PCHAR **argv,
+    CHAR c
+    );
+
+BOOLEAN
+CommonArgProcessing(
+    PULONG argc,
+    PCHAR **argv
+    );
+
+PWSTR
+FormatTempFileName(
+    PWSTR Directory,
+    PUSHORT TempFileUniqueId
+    );
+
+
+PWSTR
+CreateBackupFileName(
+    PUSHORT TempFileUniqueId
+    );
+
+
+typedef struct _ENUM_TYPE_NAMES {
+    ULONG Value;
+    LPSTR Name;
+} ENUM_TYPE_NAMES, *PENUM_TYPE_NAMES;
+
+LPSTR
+FormatEnumType(
+    ULONG BufferIndex,
+    PENUM_TYPE_NAMES Table,
+    ULONG Value,
+    BOOLEAN FlagFormat
+    );
+
+ENUM_TYPE_NAMES ValueDataTypeNames[];
diff --git a/private/sdktools/instaler/key.c b/private/sdktools/instaler/key.c
new file mode 100644
index 000000000..2b7096e4d
--- /dev/null
+++ b/private/sdktools/instaler/key.c
@@ -0,0 +1,524 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    key.c
+
+Abstract:
+
+    This module implements the functions to save references to registry
+    keys and values for the INSTALER program.  Part of each reference is
+    a a backup copy of a key information and its values that have been
+    changed/deleted.
+
+Author:
+
+    Steve Wood (stevewo) 22-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+#define DEFAULT_KEY_VALUE_BUFFER_SIZE 512
+PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
+
+VOID
+BackupKeyInfo(
+    PKEY_REFERENCE p
+    )
+{
+    NTSTATUS Status;
+    UNICODE_STRING KeyName;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    HANDLE KeyHandle;
+    KEY_FULL_INFORMATION KeyInformation;
+    ULONG ResultLength;
+    ULONG ValueIndex;
+    UNICODE_STRING ValueName;
+    PVALUE_REFERENCE ValueReference;
+
+    RtlInitUnicodeString( &KeyName, p->Name );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &KeyName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    Status = NtOpenKey( &KeyHandle,
+                        KEY_READ,
+                        &ObjectAttributes
+                      );
+    if (!NT_SUCCESS( Status )) {
+        if (Status == STATUS_OBJECT_NAME_NOT_FOUND) {
+            p->Created = TRUE;
+            p->WriteAccess = TRUE;
+            }
+
+        fprintf( InstalerLogFile, "*** Unable to open key %ws (%x)\n", p->Name, Status );
+        return;
+        }
+
+    if (!p->WriteAccess) {
+        NtClose( KeyHandle );
+        return;
+        }
+
+    fprintf( InstalerLogFile, "Saving values for %ws\n", p->Name );
+    if (KeyValueInformation == NULL) {
+        KeyValueInformation = AllocMem( DEFAULT_KEY_VALUE_BUFFER_SIZE );
+        if (KeyValueInformation == NULL) {
+            fprintf( InstalerLogFile, "*** No memory for key value information\n" );
+            return;
+            }
+        }
+
+    Status = NtQueryKey( KeyHandle,
+                         KeyFullInformation,
+                         &KeyInformation,
+                         sizeof( KeyInformation ),
+                         &ResultLength
+                       );
+    if (!NT_SUCCESS( Status ) && Status != STATUS_BUFFER_OVERFLOW) {
+        NtClose( KeyHandle );
+        fprintf( InstalerLogFile, "*** Unable to query key (%x)\n", Status );
+        return;
+        }
+
+    p->BackupKeyInfo = AllocMem( ResultLength );
+    if (p->BackupKeyInfo == NULL) {
+        NtClose( KeyHandle );
+        fprintf( InstalerLogFile, "*** No memory for backup information\n" );
+        return;
+        }
+
+    if (!NT_SUCCESS( Status )) {
+        Status = NtQueryKey( KeyHandle,
+                             KeyFullInformation,
+                             p->BackupKeyInfo,
+                             ResultLength,
+                             &ResultLength
+                           );
+        if (!NT_SUCCESS( Status )) {
+            NtClose( KeyHandle );
+            fprintf( InstalerLogFile, "*** Unable to query key (%x)\n", Status );
+            return;
+            }
+        }
+    else {
+        memmove( p->BackupKeyInfo, &KeyInformation, ResultLength );
+        }
+
+
+    for (ValueIndex = 0; TRUE; ValueIndex++) {
+        Status = NtEnumerateValueKey( KeyHandle,
+                                      ValueIndex,
+                                      KeyValueFullInformation,
+                                      KeyValueInformation,
+                                      DEFAULT_KEY_VALUE_BUFFER_SIZE,
+                                      &ResultLength
+                                    );
+        if (!NT_SUCCESS( Status ) && Status != STATUS_BUFFER_OVERFLOW) {
+            break;
+            }
+
+        ValueReference = AllocMem( FIELD_OFFSET( VALUE_REFERENCE, OriginalValue ) +
+                                   FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data ) +
+                                   KeyValueInformation->DataLength
+                                 );
+        if (ValueReference == NULL) {
+            fprintf( InstalerLogFile, "*** No memory for value ref\n", Status );
+            break;
+            }
+
+        if (KeyValueInformation->NameLength != 0) {
+            ValueName.Length = (USHORT)KeyValueInformation->NameLength;
+            ValueName.MaximumLength = ValueName.Length;
+            ValueName.Buffer = KeyValueInformation->Name;
+            ValueReference->Name = AddName( &ValueName );
+            fprintf( InstalerLogFile, "    Saving data for '%ws'\n", ValueReference->Name );
+            }
+        else {
+            fprintf( InstalerLogFile, "    Saving data for empty value name\n" );
+            }
+
+        if (Status == STATUS_BUFFER_OVERFLOW) {
+            Status = NtEnumerateValueKey( KeyHandle,
+                                          ValueIndex,
+                                          KeyValuePartialInformation,
+                                          &ValueReference->OriginalValue,
+                                          FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data ) +
+                                            KeyValueInformation->DataLength,
+                                          &ResultLength
+                                        );
+            if (!NT_SUCCESS( Status )) {
+                FreeMem( &ValueReference );
+                break;
+                }
+            }
+        else {
+            ValueReference->OriginalValue.TitleIndex = KeyValueInformation->TitleIndex;
+            ValueReference->OriginalValue.Type       = KeyValueInformation->Type;
+            ValueReference->OriginalValue.DataLength = KeyValueInformation->DataLength;
+            memmove( &ValueReference->OriginalValue.Data,
+                     (PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset,
+                     KeyValueInformation->DataLength
+                   );
+            }
+
+        InsertTailList( &p->ValueReferencesListHead, &ValueReference->Entry );
+        }
+
+    NtClose( KeyHandle );
+    return;
+}
+
+
+
+BOOLEAN
+CreateKeyReference(
+    PWSTR Name,
+    BOOLEAN WriteAccess,
+    PKEY_REFERENCE *ReturnedReference
+    )
+{
+    PKEY_REFERENCE p;
+
+    *ReturnedReference = NULL;
+    p = FindKeyReference( Name );
+    if (p != NULL) {
+        if (p->WriteAccess) {
+            *ReturnedReference = p;
+            return TRUE;
+            }
+        }
+    else {
+        p = AllocMem( sizeof( *p ) );
+        if (p == NULL) {
+            return FALSE;
+            }
+
+        p->Name = Name;
+        InsertTailList( &KeyReferenceListHead, &p->Entry );
+        NumberOfKeyReferences += 1;
+        }
+
+    InitializeListHead( &p->ValueReferencesListHead );
+    p->WriteAccess = WriteAccess;
+    BackupKeyInfo( p );
+
+    *ReturnedReference = p;
+    return TRUE;
+}
+
+
+BOOLEAN
+CompleteKeyReference(
+    PKEY_REFERENCE p,
+    BOOLEAN CallSuccessful,
+    BOOLEAN Deleted
+    )
+{
+    if (!CallSuccessful) {
+        DestroyKeyReference( p );
+        return FALSE;
+        }
+
+    if (Deleted && p->Created) {
+        LogEvent( INSTALER_EVENT_DELETE_TEMP_KEY,
+                  1,
+                  p->Name
+                );
+        DestroyKeyReference( p );
+        return FALSE;
+        }
+
+    if (Deleted) {
+        LogEvent( INSTALER_EVENT_DELETE_KEY,
+                  1,
+                  p->Name
+                );
+        }
+    else
+    if (p->WriteAccess) {
+        LogEvent( INSTALER_EVENT_WRITE_KEY,
+                  1,
+                  p->Name
+                );
+        }
+    else {
+        LogEvent( INSTALER_EVENT_READ_KEY,
+                  1,
+                  p->Name
+                );
+        }
+
+    p->Deleted = Deleted;
+    return TRUE;
+}
+
+
+BOOLEAN
+DestroyKeyReference(
+    PKEY_REFERENCE p
+    )
+{
+    RemoveEntryList( &p->Entry );
+    NumberOfKeyReferences -= 1;
+    FreeMem( &p );
+    return TRUE;
+}
+
+PKEY_REFERENCE
+FindKeyReference(
+    PWSTR Name
+    )
+{
+    PKEY_REFERENCE p;
+    PLIST_ENTRY Head, Next;
+
+    Head = &KeyReferenceListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, KEY_REFERENCE, Entry );
+        if (p->Name == Name) {
+            return p;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+VOID
+MarkKeyDeleted(
+    PKEY_REFERENCE KeyReference
+    )
+{
+    PVALUE_REFERENCE p;
+    PLIST_ENTRY Head, Next;
+
+    KeyReference->Deleted = TRUE;
+    Head = &KeyReference->ValueReferencesListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, VALUE_REFERENCE, Entry );
+        Next = Next->Flink;
+        if (p->Created || KeyReference->Created) {
+            DestroyValueReference( p );
+            }
+        else {
+            p->Deleted = TRUE;
+            }
+        }
+
+    if (KeyReference->Created) {
+        DestroyKeyReference( KeyReference );
+        }
+
+    return;
+}
+
+BOOLEAN
+CreateValueReference(
+    PPROCESS_INFO Process,
+    PKEY_REFERENCE KeyReference,
+    PWSTR Name,
+    ULONG TitleIndex,
+    ULONG Type,
+    PVOID Data,
+    ULONG DataLength,
+    PVALUE_REFERENCE *ReturnedValueReference
+    )
+{
+    PVALUE_REFERENCE p;
+    PKEY_VALUE_PARTIAL_INFORMATION OldValue, NewValue;
+
+    *ReturnedValueReference = NULL;
+
+    NewValue = AllocMem( FIELD_OFFSET( KEY_VALUE_PARTIAL_INFORMATION, Data ) +
+                         DataLength
+                       );
+    if (NewValue == NULL) {
+        return FALSE;
+        }
+
+    NewValue->TitleIndex = TitleIndex;
+    NewValue->Type = Type;
+    NewValue->DataLength = DataLength;
+    if (!ReadMemory( Process,
+                     Data,
+                     &NewValue->Data[0],
+                     DataLength,
+                     "new value data"
+                   )
+       ) {
+        FreeMem( &NewValue );
+        return FALSE;
+        }
+
+    p = FindValueReference( KeyReference, Name );
+    if (p != NULL) {
+        FreeMem( &p->Value );
+        p->Value = NewValue;
+        OldValue = &p->OriginalValue;
+        if (OldValue->TitleIndex == NewValue->TitleIndex &&
+            OldValue->Type == NewValue->Type &&
+            OldValue->DataLength == NewValue->DataLength &&
+            RtlCompareMemory( &OldValue->Data, &NewValue->Data, OldValue->DataLength )
+           ) {
+            FreeMem( &p->Value );
+            }
+        else {
+            p->Modified = TRUE;
+            }
+
+        return TRUE;
+        }
+
+    p = AllocMem( FIELD_OFFSET( VALUE_REFERENCE, OriginalValue ) );
+    if (p == NULL) {
+        FreeMem( &NewValue );
+        return FALSE;
+        }
+
+    p->Name = Name;
+    p->Created = TRUE;
+    p->Value = NewValue;
+    InsertTailList( &KeyReference->ValueReferencesListHead, &p->Entry );
+
+    *ReturnedValueReference = p;
+    return TRUE;
+}
+
+
+PVALUE_REFERENCE
+FindValueReference(
+    PKEY_REFERENCE KeyReference,
+    PWSTR Name
+    )
+{
+    PVALUE_REFERENCE p;
+    PLIST_ENTRY Head, Next;
+
+    Head = &KeyReference->ValueReferencesListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, VALUE_REFERENCE, Entry );
+        if (p->Name == Name) {
+            return p;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+
+BOOLEAN
+DestroyValueReference(
+    PVALUE_REFERENCE p
+    )
+{
+    RemoveEntryList( &p->Entry );
+    FreeMem( &p );
+    return TRUE;
+}
+
+
+VOID
+DumpKeyReferenceList(
+    FILE *LogFile
+    )
+{
+    PKEY_REFERENCE p;
+    PLIST_ENTRY Head, Next;
+    PVALUE_REFERENCE p1;
+    PLIST_ENTRY Head1, Next1;
+    PKEY_VALUE_PARTIAL_INFORMATION OldValue, NewValue;
+    KEY_VALUE_PARTIAL_INFORMATION NullValue;
+    POFFSET Values;
+
+    memset( &NullValue, 0, sizeof( NullValue ) );
+    NullValue.Type = REG_SZ;
+
+    Head = &KeyReferenceListHead;
+    Next = Head->Flink;
+    while (Head != Next) {
+        p = CONTAINING_RECORD( Next, KEY_REFERENCE, Entry );
+        if (p->Created || p->WriteAccess) {
+            Values = 0;
+            Head1 = &p->ValueReferencesListHead;
+            Next1 = Head1->Flink;
+            while (Head1 != Next1) {
+                p1 = CONTAINING_RECORD( Next1, VALUE_REFERENCE, Entry );
+                NewValue = p1->Value;
+                if (NewValue == NULL) {
+                    NewValue = &NullValue;
+                    }
+
+                OldValue = &p1->OriginalValue;
+                if (!p1->Deleted) {
+                    if (p1->Created) {
+                        ImlAddValueRecord( pImlNew,
+                                           CreateNewValue,
+                                           p1->Name,
+                                           NewValue->Type,
+                                           NewValue->DataLength,
+                                           NewValue->Data,
+                                           0,
+                                           0,
+                                           NULL,
+                                           &Values
+                                         );
+                        }
+                    else
+                    if (p1->Modified) {
+                        ImlAddValueRecord( pImlNew,
+                                           ModifyOldValue,
+                                           p1->Name,
+                                           NewValue->Type,
+                                           NewValue->DataLength,
+                                           NewValue->Data,
+                                           OldValue->Type,
+                                           OldValue->DataLength,
+                                           OldValue->Data,
+                                           &Values
+                                         );
+                        }
+                    }
+                else {
+                    ImlAddValueRecord( pImlNew,
+                                       DeleteOldValue,
+                                       p1->Name,
+                                       0,
+                                       0,
+                                       NULL,
+                                       OldValue->Type,
+                                       OldValue->DataLength,
+                                       OldValue->Data,
+                                       &Values
+                                     );
+                    }
+
+                Next1 = Next1->Flink;
+                }
+
+            ImlAddKeyRecord( pImlNew,
+                             p->Created ? CreateNewKey :
+                             p->Deleted ? DeleteOldKey : ModifyKeyValues,
+                             p->Name,
+                             Values
+                           );
+            }
+
+        Next = Next->Flink;
+        }
+
+    return;
+}
diff --git a/private/sdktools/instaler/makefile b/private/sdktools/instaler/makefile
new file mode 100644
index 000000000..6ee4f43fa
--- /dev/null
+++ b/private/sdktools/instaler/makefile
@@ -0,0 +1,6 @@
+#
+# DO NOT EDIT THIS FILE!!!  Edit .\sources. if you want to add a new source
+# file to this component.  This file merely indirects to the real make file
+# that is shared by all the components of NT OS/2
+#
+!INCLUDE $(NTMAKEENV)\makefile.def
diff --git a/private/sdktools/instaler/makefile.inc b/private/sdktools/instaler/makefile.inc
new file mode 100644
index 000000000..5c217612d
--- /dev/null
+++ b/private/sdktools/instaler/makefile.inc
@@ -0,0 +1,10 @@
+instaler.rc: errormsg.rc
+
+showinst.rc: errormsg.rc
+
+undoinst.rc: errormsg.rc
+
+compinst.rc: errormsg.rc
+
+errormsg.h errormsg.rc msg00001.bin: errormsg.mc
+    mc -v errormsg.mc
diff --git a/private/sdktools/instaler/namedb.c b/private/sdktools/instaler/namedb.c
new file mode 100644
index 000000000..3d9c2274d
--- /dev/null
+++ b/private/sdktools/instaler/namedb.c
@@ -0,0 +1,173 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    namedb.c
+
+Abstract:
+
+    This module maintains a database of path names detected by the INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 20-Aug-1994
+
+Revision History:
+
+--*/
+
+
+#include "instaler.h"
+
+typedef struct _NAME_TABLE_ENTRY {
+    struct _NAME_TABLE_ENTRY *HashLink;
+    UNICODE_STRING Name;
+    ULONG OpenCount;
+    ULONG FailedOpenCount;
+} NAME_TABLE_ENTRY, *PNAME_TABLE_ENTRY;
+
+#define NUMBER_OF_HASH_BUCKETS 37
+PNAME_TABLE_ENTRY NameTableBuckets[ NUMBER_OF_HASH_BUCKETS ];
+
+BOOLEAN
+IncrementOpenCount(
+    PWSTR Name,
+    BOOLEAN CallSuccessful
+    )
+{
+    PNAME_TABLE_ENTRY p;
+
+    p = (PNAME_TABLE_ENTRY)Name - 1;
+    if (p->Name.Buffer == Name) {
+        if (CallSuccessful) {
+            p->OpenCount += 1;
+            }
+        else {
+            p->FailedOpenCount += 1;
+            }
+        return TRUE;
+        }
+    else {
+        return FALSE;
+        }
+}
+
+ULONG
+QueryOpenCount(
+    PWSTR Name,
+    BOOLEAN CallSuccessful
+    )
+{
+    PNAME_TABLE_ENTRY p;
+
+    p = (PNAME_TABLE_ENTRY)Name - 1;
+    if (p->Name.Buffer == Name) {
+        if (CallSuccessful) {
+            return p->OpenCount;
+            }
+        else {
+            return p->FailedOpenCount;
+            }
+
+        }
+    else {
+        return 0;
+        }
+}
+
+PWSTR
+AddName(
+    PUNICODE_STRING Name
+    )
+{
+    ULONG n, Hash;
+    WCHAR c;
+    PWCH s;
+    PNAME_TABLE_ENTRY *pp, p;
+
+    n = Name->Length / sizeof( c );
+    s = Name->Buffer;
+    Hash = 0;
+    while (n--) {
+        c = RtlUpcaseUnicodeChar( *s++ );
+        Hash = Hash + (c << 1) + (c >> 1) + c;
+        }
+
+    pp = &NameTableBuckets[ Hash % NUMBER_OF_HASH_BUCKETS ];
+    while (p = *pp) {
+        if (RtlEqualUnicodeString( &p->Name, Name, TRUE )) {
+            return p->Name.Buffer;
+            }
+        else {
+            pp = &p->HashLink;
+            }
+        }
+
+    p = AllocMem( sizeof( *p ) + Name->Length + sizeof( UNICODE_NULL ) );
+    *pp = p;
+    p->HashLink = NULL;
+    p->Name.Buffer = (PWSTR)(p + 1);
+    p->Name.Length = Name->Length;
+    p->Name.MaximumLength = (USHORT)(Name->Length + sizeof( UNICODE_NULL ));
+    RtlMoveMemory( p->Name.Buffer, Name->Buffer, Name->Length );
+    p->Name.Buffer[ Name->Length / sizeof( WCHAR ) ] = UNICODE_NULL;
+    return p->Name.Buffer;
+}
+
+
+VOID
+DumpNameDataBase(
+    FILE *LogFile
+    )
+{
+    ULONG i;
+    PNAME_TABLE_ENTRY p;
+
+#if 0
+    fprintf( LogFile, "Name Data Base entries:\n" );
+    for (i=0; i<NUMBER_OF_HASH_BUCKETS; i++) {
+        p = NameTableBuckets[ i ];
+        if (p != NULL) {
+            fprintf( LogFile, "Bucket[ %02u ]:\n", i );
+            while (p) {
+                fprintf( LogFile, "    %ws\n", p->Name.Buffer );
+                p = p->HashLink;
+                }
+            }
+        }
+    fprintf( LogFile, "\n" );
+#endif
+
+    fprintf( LogFile, "List of paths with non-zero successful open counts\n" );
+    for (i=0; i<NUMBER_OF_HASH_BUCKETS; i++) {
+        p = NameTableBuckets[ i ];
+        if (p != NULL) {
+            while (p) {
+                if (p->OpenCount != 0) {
+                    fprintf( LogFile, "  %4u %ws\n", p->OpenCount, p->Name.Buffer );
+                    }
+
+                p = p->HashLink;
+                }
+            }
+        }
+    fprintf( LogFile, "\n" );
+    fprintf( LogFile, "List of paths with non-zero failed open counts\n" );
+    for (i=0; i<NUMBER_OF_HASH_BUCKETS; i++) {
+        p = NameTableBuckets[ i ];
+        if (p != NULL) {
+            while (p) {
+                if (p->FailedOpenCount != 0) {
+                    fprintf( LogFile, "  %4u %ws\n", p->FailedOpenCount, p->Name.Buffer );
+                    }
+
+                p = p->HashLink;
+                }
+            }
+        }
+    fprintf( LogFile, "\n" );
+
+    return;
+}
diff --git a/private/sdktools/instaler/process.c b/private/sdktools/instaler/process.c
new file mode 100644
index 000000000..c3a57627f
--- /dev/null
+++ b/private/sdktools/instaler/process.c
@@ -0,0 +1,560 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    process.c
+
+Abstract:
+
+    This module maintains state about each process/thread created by the application
+    setup/install program.
+
+Author:
+
+    Steve Wood (stevewo) 09-Aug-1994
+
+Revision History:
+
+--*/
+
+#include "instaler.h"
+
+BOOLEAN
+AddProcess(
+    LPDEBUG_EVENT DebugEvent,
+    PPROCESS_INFO *ReturnedProcess
+    )
+{
+    NTSTATUS Status;
+    PPROCESS_INFO Process;
+    RTL_USER_PROCESS_PARAMETERS ProcessParameters;
+    PEB Peb;
+    PWSTR FreeBuffer, s;
+
+    Process = AllocMem( sizeof( *Process ) );
+    if (Process == NULL) {
+        return FALSE;
+        }
+
+    Process->Id = DebugEvent->dwProcessId;
+    Process->Handle = DebugEvent->u.CreateProcessInfo.hProcess;
+    InitializeListHead( &Process->ThreadListHead );
+    InitializeListHead( &Process->BreakpointListHead );
+    InitializeListHead( &Process->OpenHandleListHead );
+    InsertTailList( &ProcessListHead, &Process->Entry );
+    *ReturnedProcess = Process;
+
+    Status = NtQueryInformationProcess( Process->Handle,
+                                        ProcessBasicInformation,
+                                        &Process->ProcessInformation,
+                                        sizeof( Process->ProcessInformation ),
+                                        NULL
+                                      );
+    FreeBuffer = NULL;
+    if (ReadMemory( Process,
+                    Process->ProcessInformation.PebBaseAddress,
+                    &Peb,
+                    sizeof( Peb ),
+                    "PEB"
+                  ) &&
+        Peb.ProcessParameters != NULL &&
+        ReadMemory( Process,
+                    Peb.ProcessParameters,
+                    &ProcessParameters,
+                    sizeof( ProcessParameters ),
+                    "ProcessParameters"
+                  ) &&
+        ProcessParameters.ImagePathName.Length != 0 &&
+        (FreeBuffer = AllocMem( ProcessParameters.ImagePathName.Length + sizeof( UNICODE_NULL ) )) != NULL &&
+        ReadMemory( Process,
+                    ProcessParameters.Flags & RTL_USER_PROC_PARAMS_NORMALIZED ?
+                        ProcessParameters.ImagePathName.Buffer :
+                        (PWSTR)((ULONG)(ProcessParameters.ImagePathName.Buffer) + (PCHAR)(Peb.ProcessParameters)),
+                    FreeBuffer,
+                    ProcessParameters.ImagePathName.Length,
+                    "Image File Name"
+                  )
+       ) {
+        s = (PWSTR)((PCHAR)FreeBuffer + ProcessParameters.ImagePathName.Length);
+        while (s > FreeBuffer && s[ -1 ] != OBJ_NAME_PATH_SEPARATOR) {
+            s--;
+            }
+
+        wcsncpy( Process->ImageFileName,
+                 s,
+                 (sizeof( Process->ImageFileName ) - sizeof( UNICODE_NULL )) / sizeof( WCHAR )
+               );
+        }
+    FreeMem( &FreeBuffer );
+    return TRUE;
+}
+
+BOOLEAN
+DeleteProcess(
+    PPROCESS_INFO Process
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PTHREAD_INFO Thread;
+    PBREAKPOINT_INFO Breakpoint;
+    POPENHANDLE_INFO p;
+
+    RemoveEntryList( &Process->Entry );
+
+    Head = &Process->ThreadListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        Thread = CONTAINING_RECORD( Next, THREAD_INFO, Entry );
+        Next = Next->Flink;
+        DeleteThread( Process, Thread );
+        }
+
+    Head = &Process->BreakpointListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        Breakpoint = CONTAINING_RECORD( Next, BREAKPOINT_INFO, Entry );
+        Next = Next->Flink;
+        DestroyBreakpoint( Breakpoint->Address, Process, NULL );
+        }
+
+
+    Head = &Process->OpenHandleListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        p = CONTAINING_RECORD( Next, OPENHANDLE_INFO, Entry );
+        Next = Next->Flink;
+        DeleteOpenHandle( Process, p->Handle, p->Type );
+        }
+
+    FreeMem( &Process );
+    return TRUE;
+}
+
+
+BOOLEAN
+AddThread(
+    LPDEBUG_EVENT DebugEvent,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO *ReturnedThread
+    )
+{
+    PTHREAD_INFO Thread;
+
+    Thread = AllocMem( sizeof( *Thread ) );
+    if (Thread == NULL) {
+        return FALSE;
+        }
+
+    Thread->Id = DebugEvent->dwThreadId;
+    if (DebugEvent->dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) {
+        Thread->Handle = DebugEvent->u.CreateProcessInfo.hThread;
+        Thread->StartAddress = DebugEvent->u.CreateProcessInfo.lpStartAddress;
+        }
+    else {
+        Thread->Handle = DebugEvent->u.CreateThread.hThread;
+        Thread->StartAddress = DebugEvent->u.CreateThread.lpStartAddress;
+        }
+    Thread->SingleStepExpected = FALSE;
+    InitializeListHead( &Thread->BreakpointListHead );
+    InsertTailList( &Process->ThreadListHead, &Thread->Entry );
+    *ReturnedThread = Thread;
+    return TRUE;
+}
+
+BOOLEAN
+DeleteThread(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PBREAKPOINT_INFO Breakpoint;
+
+    RemoveEntryList( &Thread->Entry );
+
+    Head = &Thread->BreakpointListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        Breakpoint = CONTAINING_RECORD( Next, BREAKPOINT_INFO, Entry );
+        Next = Next->Flink;
+        DestroyBreakpoint( Breakpoint->Address, Process, Thread );
+        }
+
+    FreeMem( &Thread );
+    return TRUE;
+}
+
+
+PPROCESS_INFO
+FindProcessById(
+    ULONG Id
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PPROCESS_INFO Process;
+
+    Head = &ProcessListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        Process = CONTAINING_RECORD( Next, PROCESS_INFO, Entry );
+        if (Process->Id == Id) {
+            return Process;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+BOOLEAN
+FindProcessAndThreadForEvent(
+    LPDEBUG_EVENT DebugEvent,
+    PPROCESS_INFO *ReturnedProcess,
+    PTHREAD_INFO *ReturnedThread
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PPROCESS_INFO Process;
+    PTHREAD_INFO Thread;
+
+    Head = &ProcessListHead;
+    Next = Head->Flink;
+    Process = NULL;
+    Thread = NULL;
+    while (Next != Head) {
+        Process = CONTAINING_RECORD( Next, PROCESS_INFO, Entry );
+        if (Process->Id == DebugEvent->dwProcessId) {
+            Head = &Process->ThreadListHead;
+            Next = Head->Flink;
+            while (Next != Head) {
+                Thread = CONTAINING_RECORD( Next, THREAD_INFO, Entry );
+                if (Thread->Id == DebugEvent->dwThreadId) {
+                    break;
+                    }
+
+                Thread = NULL;
+                Next = Next->Flink;
+                }
+
+            break;
+            }
+
+        Process = NULL;
+        Next = Next->Flink;
+        }
+
+    *ReturnedProcess = Process;
+    *ReturnedThread = Thread;
+
+    if (DebugEvent->dwDebugEventCode == CREATE_PROCESS_DEBUG_EVENT) {
+        if (Process != NULL) {
+            DeclareError( INSTALER_DUPLICATE_PROCESS_ID, 0, DebugEvent->dwProcessId );
+            return FALSE;
+            }
+        }
+    else
+    if (DebugEvent->dwDebugEventCode == CREATE_THREAD_DEBUG_EVENT) {
+        if (Thread != NULL) {
+            DeclareError( INSTALER_DUPLICATE_THREAD_ID, 0, DebugEvent->dwThreadId, DebugEvent->dwProcessId );
+            return FALSE;
+            }
+        if (Process == NULL) {
+            DeclareError( INSTALER_MISSING_PROCESS_ID, 0, DebugEvent->dwProcessId );
+            return FALSE;
+            }
+        }
+    else
+    if (Process == NULL) {
+        DeclareError( INSTALER_MISSING_PROCESS_ID, 0, DebugEvent->dwProcessId );
+        return FALSE;
+        }
+    else
+    if (Thread == NULL) {
+        DeclareError( INSTALER_MISSING_THREAD_ID, 0, DebugEvent->dwThreadId, DebugEvent->dwProcessId );
+        return FALSE;
+        }
+
+    return TRUE;
+}
+
+
+PBREAKPOINT_INFO
+FindBreakpoint(
+    LPVOID Address,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    )
+{
+    PBREAKPOINT_INFO Breakpoint;
+    PLIST_ENTRY Next, Head;
+
+    if (Thread != NULL) {
+        Head = &Thread->BreakpointListHead;
+        Next = Head->Flink;
+        while (Next != Head) {
+            Breakpoint = CONTAINING_RECORD( Next, BREAKPOINT_INFO, Entry );
+            if (Breakpoint->Address == Address) {
+                return Breakpoint;
+                }
+
+            Next = Next->Flink;
+            }
+        }
+
+    Head = &Process->BreakpointListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        Breakpoint = CONTAINING_RECORD( Next, BREAKPOINT_INFO, Entry );
+        if (Breakpoint->Address == Address) {
+            return Breakpoint;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return NULL;
+}
+
+BOOLEAN
+CreateBreakpoint(
+    LPVOID Address,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread,
+    UCHAR ApiIndex,
+    PAPI_SAVED_PARAMETERS SavedParameters,
+    PBREAKPOINT_INFO *ReturnedBreakpoint
+    )
+{
+    PBREAKPOINT_INFO Breakpoint;
+
+    Breakpoint = FindBreakpoint( Address, Process, Thread );
+
+    if (ARGUMENT_PRESENT( ReturnedBreakpoint )) {
+        *ReturnedBreakpoint = Breakpoint;
+        }
+
+    if (Breakpoint != NULL) {
+        return (Breakpoint->ApiIndex == ApiIndex);
+        }
+
+    Breakpoint = AllocMem( sizeof( *Breakpoint ) );
+    if (Breakpoint == NULL) {
+        return FALSE;
+        }
+
+    Breakpoint->Address = Address;
+    Breakpoint->ApiIndex = ApiIndex;
+    if (ARGUMENT_PRESENT( SavedParameters )) {
+        Breakpoint->SavedParameters = *SavedParameters;
+        Breakpoint->SavedParametersValid = TRUE;
+        }
+    else {
+        Breakpoint->SavedParametersValid = FALSE;
+        }
+
+    if (Thread != NULL) {
+        InsertTailList( &Thread->BreakpointListHead, &Breakpoint->Entry );
+        }
+    else {
+        InsertTailList( &Process->BreakpointListHead, &Breakpoint->Entry );
+        }
+
+    InstallBreakpoint( Process, Breakpoint );
+
+    if (ARGUMENT_PRESENT( ReturnedBreakpoint )) {
+        *ReturnedBreakpoint = Breakpoint;
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+DestroyBreakpoint(
+    LPVOID Address,
+    PPROCESS_INFO Process,
+    PTHREAD_INFO Thread
+    )
+{
+    PBREAKPOINT_INFO Breakpoint;
+
+    Breakpoint = FindBreakpoint( Address, Process, Thread );
+    if (Breakpoint == NULL) {
+        return FALSE;
+        }
+
+    RemoveBreakpoint( Process, Breakpoint );
+
+    RemoveEntryList( &Breakpoint->Entry );
+
+    FreeMem( &Breakpoint );
+    return TRUE;
+}
+
+
+BOOLEAN
+HandleThreadsForSingleStep(
+    PPROCESS_INFO Process,
+    PTHREAD_INFO ThreadToSingleStep,
+    BOOLEAN SuspendThreads
+    )
+{
+    PLIST_ENTRY Next, Head;
+    PTHREAD_INFO Thread;
+
+    Head = &Process->ThreadListHead;
+    Next = Head->Flink;
+    while (Next != Head) {
+        Thread = CONTAINING_RECORD( Next, THREAD_INFO, Entry );
+        if (Thread != ThreadToSingleStep) {
+            if (SuspendThreads) {
+                if (Thread->BreakpointToStepOver == NULL) {
+                    SuspendThread( Thread->Handle );
+                    }
+                }
+            else {
+                ResumeThread( Thread->Handle );
+                }
+
+            break;
+            }
+
+        Next = Next->Flink;
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+ReadMemory(
+    PPROCESS_INFO Process,
+    PVOID Address,
+    PVOID DataRead,
+    ULONG BytesToRead,
+    PCHAR Reason
+    )
+{
+    ULONG BytesRead;
+
+    if (!ReadProcessMemory( Process->Handle,
+                            Address,
+                            DataRead,
+                            BytesToRead,
+                            &BytesRead
+                          ) ||
+        BytesRead != BytesToRead
+       ) {
+        DbgEvent( MEMORYERROR, ( "Read memory from %x for %x bytes failed (%u) - '%s'\n",
+                                 Address,
+                                 BytesToRead,
+                                 GetLastError(),
+                                 Reason
+                               )
+                );
+        return FALSE;
+        }
+    else {
+        return TRUE;
+        }
+}
+
+
+BOOLEAN
+WriteMemory(
+    PPROCESS_INFO Process,
+    PVOID Address,
+    PVOID DataToWrite,
+    ULONG BytesToWrite,
+    PCHAR Reason
+    )
+{
+    ULONG BytesWritten;
+    ULONG OldProtection;
+    BOOLEAN Result;
+
+    if (WriteProcessMemory( Process->Handle,
+                            Address,
+                            DataToWrite,
+                            BytesToWrite,
+                            &BytesWritten
+                          ) &&
+        BytesWritten == BytesToWrite
+       ) {
+        return TRUE;
+        }
+
+    Result = FALSE;
+    if (GetLastError() == ERROR_NOACCESS &&
+        VirtualProtectEx( Process->Handle,
+                          Address,
+                          BytesToWrite,
+                          PAGE_READWRITE,
+                          &OldProtection
+                        )
+       ) {
+        if (WriteProcessMemory( Process->Handle,
+                                Address,
+                                DataToWrite,
+                                BytesToWrite,
+                                &BytesWritten
+                              ) &&
+            BytesWritten == BytesToWrite
+           ) {
+            Result = TRUE;
+            }
+        VirtualProtectEx( Process->Handle,
+                          Address,
+                          BytesToWrite,
+                          OldProtection,
+                          &OldProtection
+                        );
+        if (Result) {
+            return TRUE;
+            }
+        }
+
+    DbgEvent( MEMORYERROR, ( "Write memory to %x for %x bytes failed (%u) - '%s'\n",
+                             Address,
+                             BytesToWrite,
+                             GetLastError(),
+                             Reason
+                           )
+            );
+    return FALSE;
+}
+
+
+PVOID
+AllocMem(
+    ULONG Size
+    )
+{
+    PVOID p;
+
+    p = HeapAlloc( AppHeap, HEAP_ZERO_MEMORY, Size );
+    if (p == NULL) {
+        DbgEvent( INTERNALERROR, ( "HeapAlloc( %0x8 ) failed\n", Size ) );
+        }
+
+
+
+    return p;
+}
+
+
+VOID
+FreeMem(
+    PVOID *p
+    )
+{
+    if (*p != NULL) {
+        HeapFree( AppHeap, 0, *p );
+        *p = NULL;
+        }
+
+    return;
+}
diff --git a/private/sdktools/instaler/res.h b/private/sdktools/instaler/res.h
new file mode 100644
index 000000000..c1a489bf4
--- /dev/null
+++ b/private/sdktools/instaler/res.h
@@ -0,0 +1,2 @@
+#define FILEBMP  500
+#define DIRBMP   501
diff --git a/private/sdktools/instaler/showinst.c b/private/sdktools/instaler/showinst.c
new file mode 100644
index 000000000..9cba9b2b3
--- /dev/null
+++ b/private/sdktools/instaler/showinst.c
@@ -0,0 +1,295 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    showinst.c
+
+Abstract:
+
+    This program displays the contents of an Installation Modification Log file
+    created by the INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 15-Jan-1996
+
+Revision History:
+
+--*/
+
+#include "instutil.h"
+#include "iml.h"
+
+BOOLEAN DisplayContentsOfTextFiles;
+
+int
+ProcessShowIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml
+    );
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    int Result;
+    char *s;
+    PWSTR pw;
+    PINSTALLATION_MODIFICATION_LOGFILE pIml;
+
+    InitCommonCode( "SHOWINST",
+                    "[-c]",
+                    "-c specifies to display the contents of text files\n"
+                  );
+    DisplayContentsOfTextFiles = FALSE;
+    while (--argc) {
+        s = *++argv;
+        if (*s == '-' || *s == '/') {
+            while (*++s) {
+                switch( tolower( *s ) ) {
+                    case 'c':
+                        DisplayContentsOfTextFiles = TRUE;
+                        break;
+                    default:
+                        CommonSwitchProcessing( &argc, &argv, *s );
+                        break;
+                    }
+                }
+            }
+        else
+        if (!CommonArgProcessing( &argc, &argv )) {
+            Usage( "Arguments not supported - '%s'", (ULONG)s );
+            }
+        }
+
+    if (ImlPath == NULL) {
+        Usage( "Must specify an installation name as first argument", 0 );
+        }
+
+    if (!SetCurrentDirectory( InstalerDirectory )) {
+        FatalError( "Unable to change to '%ws' directory (%u)",
+                    (ULONG)InstalerDirectory,
+                    GetLastError()
+                  );
+        }
+
+    pIml = LoadIml( ImlPath );
+    if (pIml == NULL) {
+        FatalError( "Unable to open '%ws' (%u)",
+                    (ULONG)ImlPath,
+                    GetLastError()
+                  );
+        }
+    Result = ProcessShowIml( pIml );
+
+    CloseIml( pIml );
+    exit( Result );
+    return Result;
+}
+
+int
+ProcessShowIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pIml
+    )
+{
+    PIML_FILE_RECORD pFile;
+    PIML_FILE_RECORD_CONTENTS pOldFile;
+    PIML_FILE_RECORD_CONTENTS pNewFile;
+    PIML_KEY_RECORD pKey;
+    PIML_VALUE_RECORD pValue;
+    PIML_VALUE_RECORD_CONTENTS pOldValue;
+    PIML_VALUE_RECORD_CONTENTS pNewValue;
+    PIML_INI_RECORD pIni;
+    PIML_INISECTION_RECORD pSection;
+    PIML_INIVARIABLE_RECORD pVariable;
+    BOOLEAN FileNameShown;
+    BOOLEAN SectionNameShown;
+
+    if (pIml->NumberOfFileRecords > 0) {
+        printf( "File Modifications:\n" );
+        pFile = MP( PIML_FILE_RECORD, pIml, pIml->FileRecords );
+        while (pFile != NULL) {
+            pOldFile = MP( PIML_FILE_RECORD_CONTENTS, pIml, pFile->OldFile );
+            pNewFile = MP( PIML_FILE_RECORD_CONTENTS, pIml, pFile->NewFile );
+            printf( "    %ws - ", MP( PWSTR, pIml, pFile->Name ) );
+            switch( pFile->Action ) {
+                case CreateNewFile:
+                    printf( "created\n" );
+                    break;
+
+                case ModifyOldFile:
+                    printf( "overwritten\n" );
+                    if (pOldFile != NULL) {
+                        printf( "        Old size is %u bytes\n", pOldFile->FileSize );
+                        }
+                    break;
+
+                case DeleteOldFile:
+                    printf( "deleted\n" );
+                    if (pOldFile != NULL) {
+                        printf( "        Old size is %u bytes\n", pOldFile->FileSize );
+                        }
+                    break;
+
+                case ModifyFileDateTime:
+                    printf( "date/time modified\n" );
+                    break;
+
+                case ModifyFileAttributes:
+                    printf( "attributes modified\n" );
+                    break;
+                }
+
+            pFile = MP( PIML_FILE_RECORD, pIml, pFile->Next );
+            }
+
+        printf( "\n" );
+        }
+
+    if (pIml->NumberOfKeyRecords > 0) {
+        printf( "Registry Modifications:\n" );
+        pKey = MP( PIML_KEY_RECORD, pIml, pIml->KeyRecords );
+        while (pKey != NULL) {
+            printf( "    %ws - ", MP( PWSTR, pIml, pKey->Name ) );
+            switch( pKey->Action ) {
+                case CreateNewKey:
+                    printf( "created\n" );
+                    break;
+
+                case DeleteOldKey:
+                    printf( "deleted\n" );
+                    break;
+
+
+                case ModifyKeyValues:
+                    printf( "modified\n" );
+                    break;
+
+                }
+
+            pValue = MP( PIML_VALUE_RECORD, pIml, pKey->Values );
+            while (pValue != NULL) {
+                pOldValue = MP( PIML_VALUE_RECORD_CONTENTS, pIml, pValue->OldValue );
+                pNewValue = MP( PIML_VALUE_RECORD_CONTENTS, pIml, pValue->NewValue );
+                printf( "        %ws - ", MP( PWSTR, pIml, pValue->Name ) );
+                if (pValue->Action != DeleteOldValue) {
+                    printf( "%s [%x]",
+                            FormatEnumType( 0, ValueDataTypeNames, pNewValue->Type, FALSE ),
+                            pNewValue->Length
+                          );
+                    if (pNewValue->Type == REG_SZ ||
+                        pNewValue->Type == REG_EXPAND_SZ
+                       ) {
+                        printf( " '%ws'", MP( PWSTR, pIml, pNewValue->Data ) );
+                        }
+                    else
+                    if (pNewValue->Type == REG_DWORD) {
+                        printf( " 0x%x", *MP( PULONG, pIml, pNewValue->Data ) );
+                        }
+                    }
+
+                if (pValue->Action == CreateNewValue) {
+                    printf( " (created)\n" );
+                    }
+                else  {
+                    if (pValue->Action == DeleteOldValue) {
+                        printf( " (deleted" );
+                        }
+                    else {
+                        printf( " (modified" );
+                        }
+
+                    printf( " - was %s [%x]",
+                            FormatEnumType( 0, ValueDataTypeNames, pOldValue->Type, FALSE ),
+                            pOldValue->Length
+                          );
+                    if (pOldValue->Type == REG_SZ ||
+                        pOldValue->Type == REG_EXPAND_SZ
+                       ) {
+                        printf( " '%ws'", MP( PWSTR, pIml, pOldValue->Data ) );
+                        }
+                    else
+                    if (pOldValue->Type == REG_DWORD) {
+                        printf( " 0x%x", *MP( PULONG, pIml, pOldValue->Data ) );
+                        }
+
+                    printf( " )\n" );
+                    }
+
+                pValue = MP( PIML_VALUE_RECORD, pIml, pValue->Next );
+                }
+
+            pKey = MP( PIML_KEY_RECORD, pIml, pKey->Next );
+            }
+
+        printf( "\n" );
+        }
+
+    if (pIml->NumberOfIniRecords > 0) {
+        printf( ".INI File modifications:\n" );
+        pIni = MP( PIML_INI_RECORD, pIml, pIml->IniRecords );
+        while (pIni != NULL) {
+            FileNameShown = FALSE;
+            pSection = MP( PIML_INISECTION_RECORD, pIml, pIni->Sections );
+            while (pSection != NULL) {
+                SectionNameShown = FALSE;
+                pVariable = MP( PIML_INIVARIABLE_RECORD, pIml, pSection->Variables );
+                while (pVariable != NULL) {
+                    if (!FileNameShown) {
+                        printf( "%ws", MP( PWSTR, pIml, pIni->Name ) );
+                        if (pIni->Action == CreateNewIniFile) {
+                            printf( " (created)" );
+                            }
+                        printf( "\n" );
+                        FileNameShown = TRUE;
+                        }
+
+                    if (!SectionNameShown) {
+                        printf( "    [%ws]", MP( PWSTR, pIml, pSection->Name ) );
+                        if (pSection->Action == CreateNewSection) {
+                            printf( " (created)" );
+                            }
+                        else
+                        if (pSection->Action == DeleteOldSection) {
+                            printf( " (deleted)" );
+                            }
+                        printf( "\n" );
+
+                        SectionNameShown = TRUE;
+                        }
+
+                    printf( "        %ws = ", MP( PWSTR, pIml, pVariable->Name ) );
+                    if (pVariable->Action == CreateNewVariable) {
+                        printf( "'%ws' (created)\n", MP( PWSTR, pIml, pVariable->NewValue ) );
+                        }
+                    else
+                    if (pVariable->Action == DeleteOldVariable) {
+                        printf( " (deleted - was '%ws')\n", MP( PWSTR, pIml, pVariable->OldValue ) );
+                        }
+                    else {
+                        printf( "'%ws' (modified - was '%ws')\n",
+                                MP( PWSTR, pIml, pVariable->NewValue ),
+                                MP( PWSTR, pIml, pVariable->OldValue )
+                              );
+                        }
+
+                    pVariable = MP( PIML_INIVARIABLE_RECORD, pIml, pVariable->Next );
+                    }
+
+                pSection = MP( PIML_INISECTION_RECORD, pIml, pSection->Next );
+                }
+
+            if (FileNameShown) {
+                printf( "\n" );
+                }
+
+            pIni = MP( PIML_INI_RECORD, pIml, pIni->Next );
+            }
+        }
+
+    return 0;
+}
diff --git a/private/sdktools/instaler/showinst.rc b/private/sdktools/instaler/showinst.rc
new file mode 100644
index 000000000..399061b50
--- /dev/null
+++ b/private/sdktools/instaler/showinst.rc
@@ -0,0 +1,12 @@
+#include "instaler.h"
+#include <ntverp.h>
+
+#define	VER_FILETYPE	VFT_APP
+#define	VER_FILESUBTYPE	VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "Windows NT Instaler Display Program"
+#define VER_INTERNALNAME_STR        "SHOWINST\0"
+#define VER_ORIGINALFILENAME_STR    "SHOWINST.EXE"
+
+#include "common.ver"
+
+RCINCLUDE errormsg.rc
diff --git a/private/sdktools/instaler/sources b/private/sdktools/instaler/sources
new file mode 100644
index 000000000..c77ff7f6b
--- /dev/null
+++ b/private/sdktools/instaler/sources
@@ -0,0 +1,36 @@
+!IF 0
+
+Copyright (c) 1989  Microsoft Corporation
+
+Module Name:
+
+    sources.
+
+Abstract:
+
+    This file specifies the target component being built and the list of
+    sources files needed to build that component.  Also specifies optional
+    compiler switches and libraries that are unique for the component being
+    built.
+
+
+Author:
+
+    Steve Wood (stevewo) 12-Apr-1990
+
+NOTE:   Commented description of this file is in \nt\bak\bin\sources.tpl
+
+!ENDIF
+
+MAJORCOMP=sdktools
+MINORCOMP=instaler
+
+TARGETNAME=instaler
+TARGETPATH=obj
+TARGETTYPE=LIBRARY
+
+MSC_WARNING_LEVEL=/W3 /WX
+
+C_DEFINES=-DUNICODE -D_UNICODE
+
+SOURCES=
diff --git a/private/sdktools/instaler/test.c b/private/sdktools/instaler/test.c
new file mode 100644
index 000000000..8579fbcaf
--- /dev/null
+++ b/private/sdktools/instaler/test.c
@@ -0,0 +1,389 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    test.c
+
+Abstract:
+
+    This is a test program that issues various Kernel 32 file/registry/INI file
+    API calls so that we can see if the INSTALER program figures out correctly
+    what is being done.
+
+    This program assumes that the following conditions exist:
+
+        TEST subdirectory
+
+
+Author:
+
+    Steve Wood (stevewo) 13-Aug-1994
+
+--*/
+
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <ntdbg.h>
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+
+UCHAR AnsiBuffer[ MAX_PATH ];
+WCHAR UnicodeBuffer[ MAX_PATH ];
+
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    FILE *File0;
+    FILE *File1;
+    FILE *File2;
+    NTSTATUS Status;
+    IO_STATUS_BLOCK IoStatusBlock;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    BOOLEAN TranslationStatus;
+    UNICODE_STRING FileName;
+    RTL_RELATIVE_NAME RelativeName;
+    PVOID FreeBuffer;
+    UNICODE_STRING KeyName;
+    UNICODE_STRING SubKeyName;
+    UNICODE_STRING ValueName;
+    HANDLE FileHandle, FindHandle, KeyHandle, SubKeyHandle;
+    ULONG ValueDWord = 0x12345678;
+    WIN32_FIND_DATAW FindFileData;
+    LPSTR s1;
+    PWSTR s2;
+    UCHAR AnsiBuffer[ MAX_PATH ];
+    WCHAR UnicodeBuffer[ MAX_PATH ];
+    DWORD dwVersion;
+    OSVERSIONINFO VersionInfo;
+    HKEY hKey;
+
+    //
+    // File operations we want to test:
+    //
+    //  Creating a new file.
+    //  Deleting that file using DeleteFile (which does NtOpenFile and NtSetInformationFile
+    //  with Delete Dispostion).  (INSTALER should use this to forget about create).
+    //  Creating a new file with the same name.
+    //  Deleting that file using NtDeleteFile.  (again INSTALER should not care).
+    //
+    //  Open the TEST1 file for read access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //
+    //
+
+    // printf( "TEST: GetFileAttributes( .\\test1 )\n" );
+    GetFileAttributesA( ".\\test1" );
+#if 0
+    dwVersion = GetVersion();
+    if ((dwVersion >> 30) ^ 0x2 == VER_PLATFORM_WIN32_WINDOWS) {
+        printf( "GetVersion returns Windows 95\n" );
+        }
+    else
+    if ((dwVersion >> 30) ^ 0x2 == VER_PLATFORM_WIN32_NT) {
+        printf( "GetVersion returns Windows NT\n" );
+        }
+    else {
+        printf( "GetVersion returns %x\n", dwVersion );
+        }
+    fflush(stdout);
+
+    VersionInfo.dwOSVersionInfoSize = sizeof( VersionInfo );
+    GetVersionEx( &VersionInfo );
+    if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
+        printf( "GetVersionEx returns Windows 95\n" );
+        }
+    else
+    if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+        printf( "GetVersionEx returns Windows NT\n" );
+        }
+    else {
+        printf( "GetVersionEx returns %x\n", VersionInfo.dwPlatformId );
+        }
+    fflush(stdout);
+
+    if (RegConnectRegistryA( "\\\\stevewo_dbgr", HKEY_USERS, &hKey )) {
+        printf( "RegConnectRegistryA( \\stevewo_dbgr ) failed (hKey == %x).\n", hKey );
+        }
+    else {
+        printf( "RegConnectRegistryA( \\stevewo_dbgr ) succeeded (hKey == %x).\n", hKey );
+        RegCloseKey( hKey );
+        }
+
+    if (RegConnectRegistryW( L"\\\\stevewo_dbgr", HKEY_USERS, &hKey )) {
+        printf( "RegConnectRegistryW( \\stevewo_dbgr ) failed (hKey == %x).\n", hKey );
+        }
+    else {
+        printf( "RegConnectRegistryW( \\stevewo_dbgr ) succeeded (hKey == %x).\n", hKey );
+        RegCloseKey( hKey );
+        }
+#endif
+
+    RtlInitUnicodeString( &FileName, L"\\DosDevices\\A:" );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &FileName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    // printf( "TEST: NtOpenFile( %wZ ) should succeed without touching floppy.\n", &FileName );
+    Status = NtOpenFile( &FileHandle,
+                         SYNCHRONIZE | FILE_READ_ATTRIBUTES,
+                         &ObjectAttributes,
+                         &IoStatusBlock,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE,
+                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
+                       );
+    if (!NT_SUCCESS( Status )) {
+        printf( "TEST: Failed - Status == %x\n", Status );
+        }
+    else {
+        NtClose( FileHandle );
+        }
+
+    // printf( "TEST: FindFirstFileW( C:\\*.* should fail.\n" );
+    FindHandle = FindFirstFileW( L"C:\\*.*", &FindFileData );
+    if (FindHandle != INVALID_HANDLE_VALUE) {
+        printf( "TEST: *** oops, it worked.\n" );
+        FindClose( FindHandle );
+        }
+    // printf( "TEST: FindFirstFileW( \\TMP\\*.* should work.\n" );
+    FindHandle = FindFirstFileW( L"\\TMP\\*.*", &FindFileData );
+    if (FindHandle == INVALID_HANDLE_VALUE) {
+        printf( "TEST: *** oops, it failed.\n" );
+        }
+    else {
+        FindClose( FindHandle );
+        }
+
+    // printf( "TEST: opening .\\test0 for write access.\n" );
+    if (File0 = fopen( "test0.", "w" )) {
+        fprintf( File0, "This is test file 0\n" );
+        // printf( "TEST: closing .\\test0\n" );
+        fclose( File0 );
+        // printf( "TEST: deleting .\\test0 using DeleteFile (open, set, close)\n" );
+        DeleteFile( L"test0" );
+        }
+
+    // printf( "TEST: opening .\\test0 for write access.\n" );
+    if (File0 = fopen( "test0.", "w" )) {
+        fprintf( File0, "This is test file 0\n" );
+        // printf( "TEST: closing .\\test0\n" );
+        fclose( File0 );
+
+        TranslationStatus = RtlDosPathNameToNtPathName_U(
+                                L"test0",
+                                &FileName,
+                                NULL,
+                                &RelativeName
+                                );
+
+        if (TranslationStatus ) {
+            FreeBuffer = FileName.Buffer;
+            if ( RelativeName.RelativeName.Length ) {
+                FileName = *(PUNICODE_STRING)&RelativeName.RelativeName;
+                }
+            else {
+                RelativeName.ContainingDirectory = NULL;
+                }
+
+            InitializeObjectAttributes( &ObjectAttributes,
+                                        &FileName,
+                                        OBJ_CASE_INSENSITIVE,
+                                        RelativeName.ContainingDirectory,
+                                        NULL
+                                      );
+            // printf( "TEST: deleting .\\test0 using NtDeleteFile\n" );
+            Status = NtDeleteFile( &ObjectAttributes );
+            RtlFreeHeap( RtlProcessHeap(), 0, FreeBuffer );
+            }
+        }
+
+    // printf( "TEST: opening .\\test1 for write access.\n" );
+    if (File1 = fopen( "test1.", "w" )) {
+        fprintf( File1, "This is test file 1\n" );
+        // printf( "TEST: closing .\\test1\n" );
+        fclose( File1 );
+        }
+
+    // printf( "TEST: opening .\\test2 for write access (Instaler should noticed contents different)\n" );
+    if (File2 = fopen( "test2.", "w" )) {
+        fprintf( File2, "This is test file 2\n" );
+        // printf( "TEST: closing .\\test2\n" );
+        fclose( File2 );
+        }
+
+    // printf( "TEST: opening .\\test0.tmp for write access.\n" );
+    if (File0 = fopen( "test0.tmp", "w" )) {
+        fprintf( File0, "This is test file tmp files\n" );
+        // printf( "TEST: closing .\\test0.tmp\n" );
+        fclose( File0 );
+        // printf( "TEST: deleting .\\test0 using DeleteFile (open, set, close)\n" );
+        rename("test0.tmp", "test0.fin");
+        }
+
+    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\Software\\Test" );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &KeyName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    // printf( "TEST: opening %wZ for write access\n", &KeyName );
+    Status = NtOpenKey( &KeyHandle,
+                        KEY_WRITE,
+                        &ObjectAttributes
+                      );
+    if (NT_SUCCESS( Status )) {
+        RtlInitUnicodeString( &ValueName, L"Test0" );
+        // printf( "TEST: setting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtSetValueKey( KeyHandle,
+                                &ValueName,
+                                0,
+                                REG_SZ,
+                                "0",
+                                2 * sizeof( WCHAR )
+                              );
+
+        RtlInitUnicodeString( &ValueName, L"Test1" );
+        // printf( "TEST: deleting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtDeleteValueKey( KeyHandle,
+                                   &ValueName
+                                 );
+
+        RtlInitUnicodeString( &ValueName, L"Test2" );
+        // printf( "TEST: setting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtSetValueKey( KeyHandle,
+                                &ValueName,
+                                0,
+                                REG_DWORD,
+                                &ValueDWord,
+                                sizeof( ValueDWord )
+                              );
+        RtlInitUnicodeString( &SubKeyName, L"Test3" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: opening %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtOpenKey( &SubKeyHandle,
+                            DELETE | KEY_WRITE,
+                            &ObjectAttributes
+                          );
+        if (NT_SUCCESS( Status )) {
+            // printf( "TEST: deleting %wZ\\%wZ key and values\n", &KeyName, &SubKeyName );
+            Status = NtDeleteKey( SubKeyHandle );
+            NtClose( SubKeyHandle );
+            }
+
+        RtlInitUnicodeString( &SubKeyName, L"Test4" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: creating %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtCreateKey( &SubKeyHandle,
+                              DELETE | KEY_WRITE,
+                              &ObjectAttributes,
+                              0,
+                              NULL,
+                              0,
+                              NULL
+                            );
+        if (NT_SUCCESS( Status )) {
+            RtlInitUnicodeString( &ValueName, L"Test4" );
+            // printf( "TEST: creating %wZ\\%wZ %wZ value\n", &KeyName, &SubKeyName, &ValueName );
+            Status = NtSetValueKey( SubKeyHandle,
+                                    &ValueName,
+                                    0,
+                                    REG_DWORD,
+                                    &ValueDWord,
+                                    sizeof( ValueDWord )
+                                  );
+            NtClose( SubKeyHandle );
+            }
+
+        RtlInitUnicodeString( &SubKeyName, L"Test5" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: creating %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtCreateKey( &SubKeyHandle,
+                              DELETE | KEY_WRITE,
+                              &ObjectAttributes,
+                              0,
+                              NULL,
+                              0,
+                              NULL
+                            );
+        if (NT_SUCCESS( Status )) {
+            RtlInitUnicodeString( &ValueName, L"Test5" );
+            // printf( "TEST: creating %wZ\\%wZ %wZ value\n", &KeyName, &SubKeyName, &ValueName );
+            Status = NtSetValueKey( SubKeyHandle,
+                                    &ValueName,
+                                    0,
+                                    REG_DWORD,
+                                    &ValueDWord,
+                                    sizeof( ValueDWord )
+                                  );
+            // printf( "TEST: deleting %wZ\\%wZ key and values\n", &KeyName, &SubKeyName );
+            Status = NtDeleteKey( SubKeyHandle );
+            NtClose( SubKeyHandle );
+            }
+
+        NtClose( KeyHandle );
+        }
+
+    GetPrivateProfileStringA( "test", NULL, "",
+                              AnsiBuffer,
+                              sizeof( AnsiBuffer ),
+                              ".\\test.ini"
+                            );
+
+    GetPrivateProfileStringW( L"test", NULL, L"",
+                              UnicodeBuffer,
+                              sizeof( UnicodeBuffer ),
+                              L".\\test.ini"
+                            );
+
+
+    if (!SetCurrentDirectoryA( ".." )) {
+        printf( "TEST: SetCurrentDirectory to '..' failed (%u)\n", GetLastError() );
+        }
+
+    WriteProfileString( L"fonts", L"FooBar", L"1" );
+
+    WriteProfileString( L"fonts", L"Rockwell Italic (TrueType)", L"ROCKI.FOT" );
+
+    if (!SetCurrentDirectoryW( L"test" )) {
+        printf( "TEST: SetCurrentDirectory to 'test' failed (%u)\n", GetLastError() );
+        }
+
+    WritePrivateProfileStringA( "test", "test1", "-1", ".\\test.ini" );
+
+    WritePrivateProfileStringW( L"test", L"test1", L"-2", L".\\test.ini" );
+
+    WritePrivateProfileSectionA( "test1", "test0=0\0test1=1\0test2=2\0", ".\\test.ini" );
+
+    WritePrivateProfileSectionW( L"test2", L"test0=0\0test1=1\0test2=2\0", L".\\test.ini" );
+
+    return 0;
+}
diff --git a/private/sdktools/instaler/testins1.c b/private/sdktools/instaler/testins1.c
new file mode 100644
index 000000000..4d2c0a0f1
--- /dev/null
+++ b/private/sdktools/instaler/testins1.c
@@ -0,0 +1,384 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    testins1.c
+
+Abstract:
+
+    This is a test program that issues various Kernel 32 file/registry/INI file
+    API calls so that we can see if the INSTALER program figures out correctly
+    what is being done.
+
+Author:
+
+    Steve Wood (stevewo) 13-Aug-1994
+
+--*/
+
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <ntdbg.h>
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+
+UCHAR AnsiBuffer[ MAX_PATH ];
+WCHAR UnicodeBuffer[ MAX_PATH ];
+
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    FILE *File0;
+    FILE *File1;
+    FILE *File2;
+    NTSTATUS Status;
+    IO_STATUS_BLOCK IoStatusBlock;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    BOOLEAN TranslationStatus;
+    UNICODE_STRING FileName;
+    RTL_RELATIVE_NAME RelativeName;
+    PVOID FreeBuffer;
+    UNICODE_STRING KeyName;
+    UNICODE_STRING SubKeyName;
+    UNICODE_STRING ValueName;
+    HANDLE FileHandle, FindHandle, KeyHandle, SubKeyHandle;
+    ULONG ValueDWord = 0x12345678;
+    WIN32_FIND_DATAW FindFileData;
+    LPSTR s1;
+    PWSTR s2;
+    UCHAR AnsiBuffer[ MAX_PATH ];
+    WCHAR UnicodeBuffer[ MAX_PATH ];
+    DWORD dwVersion;
+    OSVERSIONINFO VersionInfo;
+    HKEY hKey;
+
+    //
+    // File operations we want to test:
+    //
+    //  Creating a new file.
+    //  Deleting that file using DeleteFile (which does NtOpenFile and NtSetInformationFile
+    //  with Delete Dispostion).  (INSTALER should use this to forget about create).
+    //  Creating a new file with the same name.
+    //  Deleting that file using NtDeleteFile.  (again INSTALER should not care).
+    //
+    //  Open the TEST1 file for read access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //
+    //
+
+    // printf( "TEST: GetFileAttributes( .\\test1 )\n" );
+    GetFileAttributesA( ".\\test1" );
+#if 0
+    dwVersion = GetVersion();
+    if ((dwVersion >> 30) ^ 0x2 == VER_PLATFORM_WIN32_WINDOWS) {
+        printf( "GetVersion returns Windows 95\n" );
+        }
+    else
+    if ((dwVersion >> 30) ^ 0x2 == VER_PLATFORM_WIN32_NT) {
+        printf( "GetVersion returns Windows NT\n" );
+        }
+    else {
+        printf( "GetVersion returns %x\n", dwVersion );
+        }
+    fflush(stdout);
+
+    VersionInfo.dwOSVersionInfoSize = sizeof( VersionInfo );
+    GetVersionEx( &VersionInfo );
+    if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
+        printf( "GetVersionEx returns Windows 95\n" );
+        }
+    else
+    if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+        printf( "GetVersionEx returns Windows NT\n" );
+        }
+    else {
+        printf( "GetVersionEx returns %x\n", VersionInfo.dwPlatformId );
+        }
+    fflush(stdout);
+
+    if (RegConnectRegistryA( "\\\\stevewo_dbgr", HKEY_USERS, &hKey )) {
+        printf( "RegConnectRegistryA( \\stevewo_dbgr ) failed (hKey == %x).\n", hKey );
+        }
+    else {
+        printf( "RegConnectRegistryA( \\stevewo_dbgr ) succeeded (hKey == %x).\n", hKey );
+        RegCloseKey( hKey );
+        }
+
+    if (RegConnectRegistryW( L"\\\\stevewo_dbgr", HKEY_USERS, &hKey )) {
+        printf( "RegConnectRegistryW( \\stevewo_dbgr ) failed (hKey == %x).\n", hKey );
+        }
+    else {
+        printf( "RegConnectRegistryW( \\stevewo_dbgr ) succeeded (hKey == %x).\n", hKey );
+        RegCloseKey( hKey );
+        }
+#endif
+
+    RtlInitUnicodeString( &FileName, L"\\DosDevices\\A:" );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &FileName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    // printf( "TEST: NtOpenFile( %wZ ) should succeed without touching floppy.\n", &FileName );
+    Status = NtOpenFile( &FileHandle,
+                         SYNCHRONIZE | FILE_READ_ATTRIBUTES,
+                         &ObjectAttributes,
+                         &IoStatusBlock,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE,
+                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
+                       );
+    if (!NT_SUCCESS( Status )) {
+        printf( "TEST: Failed - Status == %x\n", Status );
+        }
+    else {
+        NtClose( FileHandle );
+        }
+
+    // printf( "TEST: FindFirstFileW( C:\\*.* should fail.\n" );
+    FindHandle = FindFirstFileW( L"C:\\*.*", &FindFileData );
+    if (FindHandle != INVALID_HANDLE_VALUE) {
+        printf( "TEST: *** oops, it worked.\n" );
+        FindClose( FindHandle );
+        }
+    // printf( "TEST: FindFirstFileW( \\TMP\\*.* should work.\n" );
+    FindHandle = FindFirstFileW( L"\\TMP\\*.*", &FindFileData );
+    if (FindHandle == INVALID_HANDLE_VALUE) {
+        printf( "TEST: *** oops, it failed.\n" );
+        }
+    else {
+        FindClose( FindHandle );
+        }
+
+    // printf( "TEST: opening .\\test0 for write access.\n" );
+    if (File0 = fopen( "test0.", "w" )) {
+        fprintf( File0, "This is test file 0\n" );
+        // printf( "TEST: closing .\\test0\n" );
+        fclose( File0 );
+        // printf( "TEST: deleting .\\test0 using DeleteFile (open, set, close)\n" );
+        DeleteFile( L"test0" );
+        }
+
+    // printf( "TEST: opening .\\test0 for write access.\n" );
+    if (File0 = fopen( "test0.", "w" )) {
+        fprintf( File0, "This is test file 0\n" );
+        // printf( "TEST: closing .\\test0\n" );
+        fclose( File0 );
+
+        TranslationStatus = RtlDosPathNameToNtPathName_U(
+                                L"test0",
+                                &FileName,
+                                NULL,
+                                &RelativeName
+                                );
+
+        if (TranslationStatus ) {
+            FreeBuffer = FileName.Buffer;
+            if ( RelativeName.RelativeName.Length ) {
+                FileName = *(PUNICODE_STRING)&RelativeName.RelativeName;
+                }
+            else {
+                RelativeName.ContainingDirectory = NULL;
+                }
+
+            InitializeObjectAttributes( &ObjectAttributes,
+                                        &FileName,
+                                        OBJ_CASE_INSENSITIVE,
+                                        RelativeName.ContainingDirectory,
+                                        NULL
+                                      );
+            // printf( "TEST: deleting .\\test0 using NtDeleteFile\n" );
+            Status = NtDeleteFile( &ObjectAttributes );
+            RtlFreeHeap( RtlProcessHeap(), 0, FreeBuffer );
+            }
+        }
+
+    // printf( "TEST: opening .\\test1 for write access.\n" );
+    if (File1 = fopen( "test1.", "w" )) {
+        fprintf( File1, "This is test file 1\n" );
+        // printf( "TEST: closing .\\test1\n" );
+        fclose( File1 );
+        }
+
+    // printf( "TEST: opening .\\test2 for write access (Instaler should noticed contents different)\n" );
+    if (File2 = fopen( "test2.", "w" )) {
+        fprintf( File2, "This is test file 2\n" );
+        // printf( "TEST: closing .\\test2\n" );
+        fclose( File2 );
+        }
+
+    // printf( "TEST: opening .\\test0.tmp for write access.\n" );
+    if (File0 = fopen( "test0.tmp", "w" )) {
+        fprintf( File0, "This is test file tmp files\n" );
+        // printf( "TEST: closing .\\test0.tmp\n" );
+        fclose( File0 );
+        // printf( "TEST: deleting .\\test0 using DeleteFile (open, set, close)\n" );
+        rename("test0.tmp", "test0.fin");
+        }
+
+    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\Software\\Test" );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &KeyName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    // printf( "TEST: opening %wZ for write access\n", &KeyName );
+    Status = NtOpenKey( &KeyHandle,
+                        KEY_WRITE,
+                        &ObjectAttributes
+                      );
+    if (NT_SUCCESS( Status )) {
+        RtlInitUnicodeString( &ValueName, L"Test0" );
+        // printf( "TEST: setting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtSetValueKey( KeyHandle,
+                                &ValueName,
+                                0,
+                                REG_SZ,
+                                "0",
+                                2 * sizeof( WCHAR )
+                              );
+
+        RtlInitUnicodeString( &ValueName, L"Test1" );
+        // printf( "TEST: deleting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtDeleteValueKey( KeyHandle,
+                                   &ValueName
+                                 );
+
+        RtlInitUnicodeString( &ValueName, L"Test2" );
+        // printf( "TEST: setting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtSetValueKey( KeyHandle,
+                                &ValueName,
+                                0,
+                                REG_DWORD,
+                                &ValueDWord,
+                                sizeof( ValueDWord )
+                              );
+        RtlInitUnicodeString( &SubKeyName, L"Test3" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: opening %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtOpenKey( &SubKeyHandle,
+                            DELETE | KEY_WRITE,
+                            &ObjectAttributes
+                          );
+        if (NT_SUCCESS( Status )) {
+            // printf( "TEST: deleting %wZ\\%wZ key and values\n", &KeyName, &SubKeyName );
+            Status = NtDeleteKey( SubKeyHandle );
+            NtClose( SubKeyHandle );
+            }
+
+        RtlInitUnicodeString( &SubKeyName, L"Test4" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: creating %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtCreateKey( &SubKeyHandle,
+                              DELETE | KEY_WRITE,
+                              &ObjectAttributes,
+                              0,
+                              NULL,
+                              0,
+                              NULL
+                            );
+        if (NT_SUCCESS( Status )) {
+            RtlInitUnicodeString( &ValueName, L"Test4" );
+            // printf( "TEST: creating %wZ\\%wZ %wZ value\n", &KeyName, &SubKeyName, &ValueName );
+            Status = NtSetValueKey( SubKeyHandle,
+                                    &ValueName,
+                                    0,
+                                    REG_DWORD,
+                                    &ValueDWord,
+                                    sizeof( ValueDWord )
+                                  );
+            NtClose( SubKeyHandle );
+            }
+
+        RtlInitUnicodeString( &SubKeyName, L"Test5" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: creating %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtCreateKey( &SubKeyHandle,
+                              DELETE | KEY_WRITE,
+                              &ObjectAttributes,
+                              0,
+                              NULL,
+                              0,
+                              NULL
+                            );
+        if (NT_SUCCESS( Status )) {
+            RtlInitUnicodeString( &ValueName, L"Test5" );
+            // printf( "TEST: creating %wZ\\%wZ %wZ value\n", &KeyName, &SubKeyName, &ValueName );
+            Status = NtSetValueKey( SubKeyHandle,
+                                    &ValueName,
+                                    0,
+                                    REG_DWORD,
+                                    &ValueDWord,
+                                    sizeof( ValueDWord )
+                                  );
+            // printf( "TEST: deleting %wZ\\%wZ key and values\n", &KeyName, &SubKeyName );
+            Status = NtDeleteKey( SubKeyHandle );
+            NtClose( SubKeyHandle );
+            }
+
+        NtClose( KeyHandle );
+        }
+
+    GetPrivateProfileStringA( "test", NULL, "",
+                              AnsiBuffer,
+                              sizeof( AnsiBuffer ),
+                              ".\\test.ini"
+                            );
+
+    GetPrivateProfileStringW( L"test", NULL, L"",
+                              UnicodeBuffer,
+                              sizeof( UnicodeBuffer ),
+                              L".\\test.ini"
+                            );
+
+
+    if (!SetCurrentDirectoryA( ".." )) {
+        printf( "TEST: SetCurrentDirectory to '..' failed (%u)\n", GetLastError() );
+        }
+
+    WriteProfileString( L"fonts", L"FooBar", L"1" );
+
+    WriteProfileString( L"fonts", L"Rockwell Italic (TrueType)", L"ROCKI.FOT" );
+
+    if (!SetCurrentDirectoryW( L"test" )) {
+        printf( "TEST: SetCurrentDirectory to 'test' failed (%u)\n", GetLastError() );
+        }
+
+    WritePrivateProfileStringA( "test", "test1", "-1", ".\\test.ini" );
+
+    WritePrivateProfileStringW( L"test", L"test1", L"-2", L".\\test.ini" );
+
+    WritePrivateProfileSectionA( "test1", "test0=0\0test1=1\0test2=2\0", ".\\test.ini" );
+
+    WritePrivateProfileSectionW( L"test2", L"test0=0\0test1=1\0test2=2\0", L".\\test.ini" );
+
+    return 0;
+}
diff --git a/private/sdktools/instaler/testins1.rc b/private/sdktools/instaler/testins1.rc
new file mode 100644
index 000000000..75c36422f
--- /dev/null
+++ b/private/sdktools/instaler/testins1.rc
@@ -0,0 +1,12 @@
+#include "instaler.h"
+#include <ntverp.h>
+
+#define	VER_FILETYPE	VFT_APP
+#define	VER_FILESUBTYPE	VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "Windows NT Instaler Test Program"
+#define VER_INTERNALNAME_STR        "TESTINST\0"
+#define VER_ORIGINALFILENAME_STR    "TESTINST.EXE"
+
+#include "common.ver"
+
+RCINCLUDE errormsg.rc
diff --git a/private/sdktools/instaler/testins2.c b/private/sdktools/instaler/testins2.c
new file mode 100644
index 000000000..23513d751
--- /dev/null
+++ b/private/sdktools/instaler/testins2.c
@@ -0,0 +1,387 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    testins2.c
+
+Abstract:
+
+    This is a test program that issues various Kernel 32 file/registry/INI file
+    API calls so that we can see if the INSTALER program figures out correctly
+    what is being done.
+
+Author:
+
+    Steve Wood (stevewo) 13-Aug-1994
+
+--*/
+
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+#include <ntdbg.h>
+#include <windows.h>
+#include <stdio.h>
+#include <string.h>
+
+UCHAR AnsiBuffer[ MAX_PATH ];
+WCHAR UnicodeBuffer[ MAX_PATH ];
+
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    FILE *File0;
+    FILE *File1;
+    FILE *File2;
+    NTSTATUS Status;
+    IO_STATUS_BLOCK IoStatusBlock;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    BOOLEAN TranslationStatus;
+    UNICODE_STRING FileName;
+    RTL_RELATIVE_NAME RelativeName;
+    PVOID FreeBuffer;
+    UNICODE_STRING KeyName;
+    UNICODE_STRING SubKeyName;
+    UNICODE_STRING ValueName;
+    HANDLE FileHandle, FindHandle, KeyHandle, SubKeyHandle;
+    ULONG ValueDWord = 0x12345679;
+    WIN32_FIND_DATAW FindFileData;
+    LPSTR s1;
+    PWSTR s2;
+    UCHAR AnsiBuffer[ MAX_PATH ];
+    WCHAR UnicodeBuffer[ MAX_PATH ];
+    DWORD dwVersion;
+    OSVERSIONINFO VersionInfo;
+    HKEY hKey;
+
+    //
+    // File operations we want to test:
+    //
+    //  Creating a new file.
+    //  Deleting that file using DeleteFile (which does NtOpenFile and NtSetInformationFile
+    //  with Delete Dispostion).  (INSTALER should use this to forget about create).
+    //  Creating a new file with the same name.
+    //  Deleting that file using NtDeleteFile.  (again INSTALER should not care).
+    //
+    //  Open the TEST1 file for read access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //  Open the TEST2 file for write access (INSTALER should not care).
+    //
+    //
+
+    // printf( "TEST: GetFileAttributes( .\\test1 )\n" );
+    GetFileAttributesA( ".\\test1" );
+#if 0
+    dwVersion = GetVersion();
+    if ((dwVersion >> 30) ^ 0x2 == VER_PLATFORM_WIN32_WINDOWS) {
+        printf( "GetVersion returns Windows 95\n" );
+        }
+    else
+    if ((dwVersion >> 30) ^ 0x2 == VER_PLATFORM_WIN32_NT) {
+        printf( "GetVersion returns Windows NT\n" );
+        }
+    else {
+        printf( "GetVersion returns %x\n", dwVersion );
+        }
+    fflush(stdout);
+
+    VersionInfo.dwOSVersionInfoSize = sizeof( VersionInfo );
+    GetVersionEx( &VersionInfo );
+    if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_WINDOWS) {
+        printf( "GetVersionEx returns Windows 95\n" );
+        }
+    else
+    if (VersionInfo.dwPlatformId == VER_PLATFORM_WIN32_NT) {
+        printf( "GetVersionEx returns Windows NT\n" );
+        }
+    else {
+        printf( "GetVersionEx returns %x\n", VersionInfo.dwPlatformId );
+        }
+    fflush(stdout);
+
+    if (RegConnectRegistryA( "\\\\stevewo_dbgr", HKEY_USERS, &hKey )) {
+        printf( "RegConnectRegistryA( \\stevewo_dbgr ) failed (hKey == %x).\n", hKey );
+        }
+    else {
+        printf( "RegConnectRegistryA( \\stevewo_dbgr ) succeeded (hKey == %x).\n", hKey );
+        RegCloseKey( hKey );
+        }
+
+    if (RegConnectRegistryW( L"\\\\stevewo_dbgr", HKEY_USERS, &hKey )) {
+        printf( "RegConnectRegistryW( \\stevewo_dbgr ) failed (hKey == %x).\n", hKey );
+        }
+    else {
+        printf( "RegConnectRegistryW( \\stevewo_dbgr ) succeeded (hKey == %x).\n", hKey );
+        RegCloseKey( hKey );
+        }
+#endif
+
+    RtlInitUnicodeString( &FileName, L"\\DosDevices\\A:" );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &FileName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    // printf( "TEST: NtOpenFile( %wZ ) should succeed without touching floppy.\n", &FileName );
+    Status = NtOpenFile( &FileHandle,
+                         SYNCHRONIZE | FILE_READ_ATTRIBUTES,
+                         &ObjectAttributes,
+                         &IoStatusBlock,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE,
+                         FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE
+                       );
+    if (!NT_SUCCESS( Status )) {
+        printf( "TEST: Failed - Status == %x\n", Status );
+        }
+    else {
+        NtClose( FileHandle );
+        }
+
+    // printf( "TEST: FindFirstFileW( C:\\*.* should fail.\n" );
+    FindHandle = FindFirstFileW( L"C:\\*.*", &FindFileData );
+    if (FindHandle != INVALID_HANDLE_VALUE) {
+        printf( "TEST: *** oops, it worked.\n" );
+        FindClose( FindHandle );
+        }
+    // printf( "TEST: FindFirstFileW( \\TMP\\*.* should work.\n" );
+    FindHandle = FindFirstFileW( L"\\TMP\\*.*", &FindFileData );
+    if (FindHandle == INVALID_HANDLE_VALUE) {
+        printf( "TEST: *** oops, it failed.\n" );
+        }
+    else {
+        FindClose( FindHandle );
+        }
+
+    // printf( "TEST: opening .\\test0 for write access.\n" );
+    if (File0 = fopen( "test0.", "w" )) {
+        fprintf( File0, "This is test file 0\n" );
+        // printf( "TEST: closing .\\test0\n" );
+        fclose( File0 );
+        // printf( "TEST: deleting .\\test0 using DeleteFile (open, set, close)\n" );
+        DeleteFile( L"test0" );
+        }
+
+    // printf( "TEST: opening .\\test0 for write access.\n" );
+    if (File0 = fopen( "test0.", "w" )) {
+        fprintf( File0, "This is test file 0\n" );
+        // printf( "TEST: closing .\\test0\n" );
+        fclose( File0 );
+#if 0
+        TranslationStatus = RtlDosPathNameToNtPathName_U(
+                                L"test0",
+                                &FileName,
+                                NULL,
+                                &RelativeName
+                                );
+
+        if (TranslationStatus ) {
+            FreeBuffer = FileName.Buffer;
+            if ( RelativeName.RelativeName.Length ) {
+                FileName = *(PUNICODE_STRING)&RelativeName.RelativeName;
+                }
+            else {
+                RelativeName.ContainingDirectory = NULL;
+                }
+
+            InitializeObjectAttributes( &ObjectAttributes,
+                                        &FileName,
+                                        OBJ_CASE_INSENSITIVE,
+                                        RelativeName.ContainingDirectory,
+                                        NULL
+                                      );
+            // printf( "TEST: deleting .\\test0 using NtDeleteFile\n" );
+            Status = NtDeleteFile( &ObjectAttributes );
+            RtlFreeHeap( RtlProcessHeap(), 0, FreeBuffer );
+            }
+#endif
+        }
+
+    // printf( "TEST: opening .\\test1 for write access.\n" );
+    if (File1 = fopen( "test1.", "w" )) {
+        fprintf( File1, "This is test file 1a\n" );
+        // printf( "TEST: closing .\\test1\n" );
+        fclose( File1 );
+        }
+
+    // printf( "TEST: opening .\\test2 for write access (Instaler should noticed contents different)\n" );
+    if (File2 = fopen( "test2.", "w" )) {
+        fprintf( File2, "This is test file 2\n" );
+        // printf( "TEST: closing .\\test2\n" );
+        fclose( File2 );
+        }
+
+    // printf( "TEST: opening .\\test0.tmp for write access.\n" );
+    if (File0 = fopen( "test0.tmp", "w" )) {
+        fprintf( File0, "This is test file tmp files\n" );
+        // printf( "TEST: closing .\\test0.tmp\n" );
+        fclose( File0 );
+        // printf( "TEST: deleting .\\test0 using DeleteFile (open, set, close)\n" );
+        rename("test0.tmp", "test0.fin");
+        }
+    rename("test1.", "test2.fin");
+    rename("test3.", "test3.fin");
+
+    RtlInitUnicodeString( &KeyName, L"\\Registry\\Machine\\Software\\Test" );
+    InitializeObjectAttributes( &ObjectAttributes,
+                                &KeyName,
+                                OBJ_CASE_INSENSITIVE,
+                                NULL,
+                                NULL
+                              );
+    // printf( "TEST: opening %wZ for write access\n", &KeyName );
+    Status = NtOpenKey( &KeyHandle,
+                        KEY_WRITE,
+                        &ObjectAttributes
+                      );
+    if (NT_SUCCESS( Status )) {
+        RtlInitUnicodeString( &ValueName, L"Test0" );
+        // printf( "TEST: setting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtSetValueKey( KeyHandle,
+                                &ValueName,
+                                0,
+                                REG_SZ,
+                                "1",
+                                2 * sizeof( WCHAR )
+                              );
+
+        RtlInitUnicodeString( &ValueName, L"Test1" );
+        // printf( "TEST: deleting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtDeleteValueKey( KeyHandle,
+                                   &ValueName
+                                 );
+
+        RtlInitUnicodeString( &ValueName, L"Test2" );
+        // printf( "TEST: setting %wZ . %wZ value\n", &KeyName, &ValueName );
+        Status = NtSetValueKey( KeyHandle,
+                                &ValueName,
+                                0,
+                                REG_DWORD,
+                                &ValueDWord,
+                                sizeof( ValueDWord )
+                              );
+        RtlInitUnicodeString( &SubKeyName, L"Test3" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: opening %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtOpenKey( &SubKeyHandle,
+                            DELETE | KEY_WRITE,
+                            &ObjectAttributes
+                          );
+        if (NT_SUCCESS( Status )) {
+            // printf( "TEST: deleting %wZ\\%wZ key and values\n", &KeyName, &SubKeyName );
+            Status = NtDeleteKey( SubKeyHandle );
+            NtClose( SubKeyHandle );
+            }
+
+        RtlInitUnicodeString( &SubKeyName, L"Test4" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: creating %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtCreateKey( &SubKeyHandle,
+                              DELETE | KEY_WRITE,
+                              &ObjectAttributes,
+                              0,
+                              NULL,
+                              0,
+                              NULL
+                            );
+        if (NT_SUCCESS( Status )) {
+            RtlInitUnicodeString( &ValueName, L"Test4" );
+            // printf( "TEST: creating %wZ\\%wZ %wZ value\n", &KeyName, &SubKeyName, &ValueName );
+            Status = NtSetValueKey( SubKeyHandle,
+                                    &ValueName,
+                                    0,
+                                    REG_DWORD,
+                                    &ValueDWord,
+                                    sizeof( ValueDWord )
+                                  );
+            NtClose( SubKeyHandle );
+            }
+
+        RtlInitUnicodeString( &SubKeyName, L"Test5" );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &SubKeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    KeyHandle,
+                                    NULL
+                                  );
+        // printf( "TEST: creating %wZ\\%wZ for write access\n", &KeyName, &SubKeyName );
+        Status = NtCreateKey( &SubKeyHandle,
+                              DELETE | KEY_WRITE,
+                              &ObjectAttributes,
+                              0,
+                              NULL,
+                              0,
+                              NULL
+                            );
+        if (NT_SUCCESS( Status )) {
+            RtlInitUnicodeString( &ValueName, L"Test5" );
+            // printf( "TEST: creating %wZ\\%wZ %wZ value\n", &KeyName, &SubKeyName, &ValueName );
+            Status = NtSetValueKey( SubKeyHandle,
+                                    &ValueName,
+                                    0,
+                                    REG_DWORD,
+                                    &ValueDWord,
+                                    sizeof( ValueDWord )
+                                  );
+            // printf( "TEST: deleting %wZ\\%wZ key and values\n", &KeyName, &SubKeyName );
+            Status = NtDeleteKey( SubKeyHandle );
+            NtClose( SubKeyHandle );
+            }
+
+        NtClose( KeyHandle );
+        }
+
+    GetPrivateProfileStringA( "test", NULL, "",
+                              AnsiBuffer,
+                              sizeof( AnsiBuffer ),
+                              ".\\test.ini"
+                            );
+
+    GetPrivateProfileStringW( L"test", NULL, L"",
+                              UnicodeBuffer,
+                              sizeof( UnicodeBuffer ),
+                              L".\\test.ini"
+                            );
+
+
+    if (!SetCurrentDirectoryA( ".." )) {
+        printf( "TEST: SetCurrentDirectory to '..' failed (%u)\n", GetLastError() );
+        }
+
+    WriteProfileString( L"fonts", L"FooBar", L"2" );
+
+    WriteProfileString( L"fonts", L"Rockwell Italic (TrueType)", L"ROCKI.FOT" );
+
+    if (!SetCurrentDirectoryW( L"test" )) {
+        printf( "TEST: SetCurrentDirectory to 'test' failed (%u)\n", GetLastError() );
+        }
+
+    WritePrivateProfileStringA( "test", "test1", "-1", ".\\test.ini" );
+
+    WritePrivateProfileStringW( L"test", L"test1", L"-3", L".\\test.ini" );
+
+    WritePrivateProfileSectionA( "test1", "test0=0\0test1=1\0test2=2\0", ".\\test.ini" );
+
+    WritePrivateProfileSectionW( L"test2", L"test0=0\0test1=2\0test2=2\0", L".\\test.ini" );
+
+    return 0;
+}
diff --git a/private/sdktools/instaler/testins2.rc b/private/sdktools/instaler/testins2.rc
new file mode 100644
index 000000000..75c36422f
--- /dev/null
+++ b/private/sdktools/instaler/testins2.rc
@@ -0,0 +1,12 @@
+#include "instaler.h"
+#include <ntverp.h>
+
+#define	VER_FILETYPE	VFT_APP
+#define	VER_FILESUBTYPE	VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "Windows NT Instaler Test Program"
+#define VER_INTERNALNAME_STR        "TESTINST\0"
+#define VER_ORIGINALFILENAME_STR    "TESTINST.EXE"
+
+#include "common.ver"
+
+RCINCLUDE errormsg.rc
diff --git a/private/sdktools/instaler/undoinst.c b/private/sdktools/instaler/undoinst.c
new file mode 100644
index 000000000..30e8ace5a
--- /dev/null
+++ b/private/sdktools/instaler/undoinst.c
@@ -0,0 +1,831 @@
+/*++
+
+Copyright (c) 1992  Microsoft Corporation
+
+Module Name:
+
+    undoinst.c
+
+Abstract:
+
+    This program undoes the actions described by an Installation Modification Log file
+    created by the INSTALER program
+
+Author:
+
+    Steve Wood (stevewo) 15-Jan-1996
+
+Revision History:
+
+--*/
+
+#include <nt.h>
+#include <ntrtl.h>
+#include <nturtl.h>
+
+#include "instutil.h"
+#include "iml.h"
+
+BOOLEAN RedoScript;
+BOOLEAN VerboseOutput;
+
+int
+ProcessUndoIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PINSTALLATION_MODIFICATION_LOGFILE pImlRedo
+    );
+
+int
+_CRTAPI1
+main(
+    int argc,
+    char *argv[]
+    )
+{
+    int Result;
+    char *s;
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo;
+    PINSTALLATION_MODIFICATION_LOGFILE pImlRedo;
+    USHORT RedoScriptId;
+
+    InitCommonCode( "UNDOINST",
+                    "[-r] [-v]",
+                    "-r replace contents of input .IML file with redo script to undo the undo\n"
+                    "-v verbose output\n"
+                  );
+    RedoScript = FALSE;
+    VerboseOutput = FALSE;
+    while (--argc) {
+        s = *++argv;
+        if (*s == '-' || *s == '/') {
+            while (*++s) {
+                switch( tolower( *s ) ) {
+                    case 'r':
+                        RedoScript = TRUE;
+                        break;
+                    case 'v':
+                        VerboseOutput = TRUE;
+                        break;
+                    default:
+                        CommonSwitchProcessing( &argc, &argv, *s );
+                        break;
+                    }
+                }
+            }
+        else
+        if (!CommonArgProcessing( &argc, &argv )) {
+            Usage( "Arguments not supported - '%s'", (ULONG)s );
+            }
+        }
+
+    if (ImlPath == NULL) {
+        Usage( "Must specify an installation name as first argument", 0 );
+        }
+
+    if (!SetCurrentDirectory( InstalerDirectory )) {
+        FatalError( "Unable to change to '%ws' directory (%u)",
+                    (ULONG)InstalerDirectory,
+                    GetLastError()
+                  );
+        }
+
+    pImlUndo = LoadIml( ImlPath );
+    if (pImlUndo == NULL) {
+        FatalError( "Unable to open '%ws' (%u)",
+                    (ULONG)ImlPath,
+                    GetLastError()
+                  );
+        }
+    if (RedoScript) {
+        RedoScriptId = 0;
+        if (CreateBackupFileName( &RedoScriptId ) == NULL) {
+            FatalError( "Unable to create temporary file for redo script (%u)\n",
+                        GetLastError(),
+                        0
+                      );
+            }
+
+        pImlRedo = CreateIml( FormatTempFileName( InstalerDirectory, &RedoScriptId ), TRUE );
+        if (pImlRedo == NULL) {
+            FatalError( "Unable to create redo script '%ws' (%u)\n",
+                        (ULONG)FormatTempFileName( InstalerDirectory, &RedoScriptId ),
+                        GetLastError()
+                      );
+            }
+        }
+    else {
+        pImlRedo = NULL;
+        }
+
+    Result = ProcessUndoIml( pImlUndo, pImlRedo );
+
+    CloseIml( pImlUndo );
+    if (pImlRedo != NULL) {
+        CloseIml( pImlRedo );
+        if (!MoveFileEx( FormatTempFileName( InstalerDirectory, &RedoScriptId ),
+                         ImlPath,
+                         MOVEFILE_REPLACE_EXISTING | MOVEFILE_COPY_ALLOWED
+                       )
+           ) {
+            FatalError( "Unable to rename redo script '%ws' (%u)\n",
+                        (ULONG)FormatTempFileName( InstalerDirectory, &RedoScriptId ),
+                        GetLastError()
+                      );
+            }
+        }
+
+    exit( Result );
+    return Result;
+}
+
+
+BOOLEAN
+DeleteFileOrDirectory(
+    PWSTR Name
+    )
+{
+    DWORD FileAttributes;
+
+    FileAttributes = GetFileAttributes( Name );
+    if (FileAttributes == 0xFFFFFFFF) {
+        return TRUE;
+        }
+
+    if (FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+        return RemoveDirectory( Name );
+        }
+    else {
+        return DeleteFile( Name );
+        }
+}
+
+BOOLEAN
+ProcessUndoFileIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PIML_FILE_RECORD pFile
+    )
+{
+    PIML_FILE_RECORD_CONTENTS pOldFile;
+    PIML_FILE_RECORD_CONTENTS pNewFile;
+    USHORT UniqueId = 0;
+    HANDLE FileHandle;
+    PWSTR BackupFileName;
+    DWORD FileAttributes;
+    DWORD BytesWritten;
+
+    pOldFile = MP( PIML_FILE_RECORD_CONTENTS, pImlUndo, pFile->OldFile );
+    pNewFile = MP( PIML_FILE_RECORD_CONTENTS, pImlUndo, pFile->NewFile );
+    printf( "    %ws - ", MP( PWSTR, pImlUndo, pFile->Name ) );
+    switch( pFile->Action ) {
+        case CreateNewFile:
+            printf( "deleting" );
+            SetFileAttributes( MP( PWSTR, pImlUndo, pFile->Name ),
+                               FILE_ATTRIBUTE_NORMAL
+                             );
+            if (!DeleteFileOrDirectory( MP( PWSTR, pImlUndo, pFile->Name ) )) {
+                printf( " - error (%u)", GetLastError() );
+                }
+            printf( "\n" );
+            break;
+
+        case ModifyOldFile:
+        case DeleteOldFile:
+            FileAttributes = GetFileAttributes( MP( PWSTR, pImlUndo, pFile->Name ) );
+            printf( "restoring old file" );
+            if (FileAttributes != 0xFFFFFFFF) {
+                SetFileAttributes( MP( PWSTR, pImlUndo, pFile->Name ),
+                                   FILE_ATTRIBUTE_NORMAL
+                                 );
+                BackupFileName = CreateBackupFileName( &UniqueId );
+                if (BackupFileName == NULL) {
+                    printf( " - unable to find temporary name for restore\n" );
+                    break;
+                    }
+                else
+                if (!MoveFile( MP( PWSTR, pImlUndo, pFile->Name ),
+                               BackupFileName
+                             )
+                   ) {
+                    printf( " - unable to rename existing to temporary name (%u)\n",
+                            GetLastError()
+                          );
+                    break;
+                    }
+                }
+            else {
+                BackupFileName = NULL;
+                }
+
+            if (pOldFile != NULL) {
+                if (pOldFile->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
+                    if (!CreateDirectory( MP( PWSTR, pImlUndo, pFile->Name ), NULL )) {
+                        printf( " - unable to create directory (%u)",
+                                GetLastError()
+                              );
+                        }
+                    }
+                else {
+                    FileHandle = CreateFile( MP( PWSTR, pImlUndo, pFile->Name ),
+                                             GENERIC_WRITE,
+                                             FILE_SHARE_READ,
+                                             NULL,
+                                             CREATE_NEW,
+                                             0,
+                                             NULL
+                                           );
+                    if (FileHandle != INVALID_HANDLE_VALUE) {
+                        if (WriteFile( FileHandle,
+                                       MP( PVOID, pImlUndo, pOldFile->Contents ),
+                                       pOldFile->FileSize,
+                                       &BytesWritten,
+                                       NULL
+                                     ) &&
+                            BytesWritten == pOldFile->FileSize
+                           ) {
+                            if (!SetFileAttributes( MP( PWSTR, pImlUndo, pFile->Name ),
+                                                    pOldFile->FileAttributes
+                                                  )
+                               ) {
+                                printf( " - unable to restore attributes (%u)",
+                                        GetLastError()
+                                      );
+                                }
+                            else
+                            if (!SetFileTime( FileHandle,
+                                              &pOldFile->LastWriteTime,
+                                              &pOldFile->LastWriteTime,
+                                              &pOldFile->LastWriteTime
+                                            )
+                               ) {
+                                printf( " - unable to restore last write time (%u)",
+                                        GetLastError()
+                                      );
+                                }
+                            else
+                            if (BackupFileName != NULL) {
+                                DeleteFile( BackupFileName );
+                                BackupFileName = NULL;
+                                }
+                            }
+                        else {
+                            printf( " - unable to restore contents (%u)",
+                                    GetLastError()
+                                  );
+                            }
+
+                        CloseHandle( FileHandle );
+                        }
+                    else {
+                        printf( " - unable to create file (%u)",
+                                GetLastError()
+                              );
+                        }
+                    }
+                }
+            else {
+                printf( " - old contents missing from .IML file" );
+                }
+
+            if (BackupFileName != NULL) {
+                DeleteFile( MP( PWSTR, pImlUndo, pFile->Name ) );
+                MoveFile( BackupFileName, MP( PWSTR, pImlUndo, pFile->Name ) );
+                }
+            printf( "\n" );
+            break;
+
+        case ModifyFileDateTime:
+            printf( "restoring date/time\n" );
+            FileHandle = CreateFile( MP( PWSTR, pImlUndo, pFile->Name ),
+                                     FILE_WRITE_ATTRIBUTES,
+                                     FILE_SHARE_READ,
+                                     NULL,
+                                     OPEN_EXISTING,
+                                     0,
+                                     NULL
+                                   );
+            if (FileHandle != INVALID_HANDLE_VALUE) {
+                if (!SetFileTime( FileHandle,
+                                  &pOldFile->LastWriteTime,
+                                  &pOldFile->LastWriteTime,
+                                  &pOldFile->LastWriteTime
+                                )
+                   ) {
+                    printf( " - unable to restore last write time (%u)",
+                            GetLastError()
+                          );
+                    }
+
+                CloseHandle( FileHandle );
+                }
+            else {
+                printf( " - unable to open file (%u)",
+                        GetLastError()
+                      );
+                }
+            break;
+
+        case ModifyFileAttributes:
+            printf( "restoring attributes" );
+            if (!SetFileAttributes( MP( PWSTR, pImlUndo, pFile->Name ),
+                                    pOldFile->FileAttributes
+                                  )
+               ) {
+                printf( " - unable to restore attributes (%u)",
+                        GetLastError()
+                      );
+                }
+            printf( "\n" );
+            break;
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+ProcessRedoFileIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PIML_FILE_RECORD pFile,
+    PINSTALLATION_MODIFICATION_LOGFILE pImlRedo
+    )
+{
+    HANDLE FindHandle;
+    WIN32_FIND_DATA FindFileData;
+
+    if (pFile->Action == CreateNewFile) {
+        //
+        // Created a new file.  So do the same in the redo
+        // script, with the existing contents of the new file
+        //
+        ImlAddFileRecord( pImlRedo,
+                          CreateNewFile,
+                          MP( PWSTR, pImlUndo, pFile->Name ),
+                          NULL,
+                          NULL,
+                          0
+                        );
+        }
+    else
+    if (pFile->Action == ModifyOldFile) {
+        //
+        // Modified an existing file.  Create a similar record
+        // in the redo script that will hold the new contents
+        //
+        ImlAddFileRecord( pImlRedo,
+                          ModifyOldFile,
+                          MP( PWSTR, pImlUndo, pFile->Name ),
+                          NULL,
+                          NULL,
+                          0
+                        );
+        }
+    else {
+        //
+        // Modified the file attributes and/or date and time.  Get the current
+        // values and save them in the redo script
+        //
+        FindHandle = FindFirstFile( MP( PWSTR, pImlUndo, pFile->Name ),
+                                    &FindFileData
+                                  );
+        if (FindHandle != INVALID_HANDLE_VALUE) {
+            ImlAddFileRecord( pImlRedo,
+                              ModifyFileDateTime,
+                              MP( PWSTR, pImlUndo, pFile->Name ),
+                              NULL,
+                              &FindFileData.ftLastWriteTime,
+                              FindFileData.dwFileAttributes
+                            );
+            FindClose( FindHandle );
+            }
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+ProcessUndoKeyIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PIML_KEY_RECORD pKey
+    )
+{
+    PIML_VALUE_RECORD pValue;
+    PIML_VALUE_RECORD_CONTENTS pOldValue;
+    PIML_VALUE_RECORD_CONTENTS pNewValue;
+    NTSTATUS Status;
+    UNICODE_STRING KeyName;
+    OBJECT_ATTRIBUTES ObjectAttributes;
+    HANDLE KeyHandle;
+    UNICODE_STRING ValueName;
+
+    KeyHandle = NULL;
+    if (pKey->Values != 0 || pKey->Action == CreateNewKey) {
+        printf( "    %ws - ", MP( PWSTR, pImlUndo, pKey->Name ) );
+        RtlInitUnicodeString( &KeyName, MP( PWSTR, pImlUndo, pKey->Name ) );
+        InitializeObjectAttributes( &ObjectAttributes,
+                                    &KeyName,
+                                    OBJ_CASE_INSENSITIVE,
+                                    NULL,
+                                    NULL
+                                  );
+        if (pKey->Action != DeleteOldKey) {
+            if (pKey->Action == CreateNewKey) {
+                printf( "deleting" );
+                }
+            else {
+                printf( "modifying" );
+                }
+            Status = NtOpenKey( &KeyHandle, DELETE | GENERIC_WRITE, &ObjectAttributes );
+            }
+        else {
+            printf( "creating" );
+            Status = NtCreateKey( &KeyHandle,
+                                  GENERIC_WRITE,
+                                  &ObjectAttributes,
+                                  0,
+                                  NULL,
+                                  0,
+                                  NULL
+                                );
+            }
+
+        if (!NT_SUCCESS( Status )) {
+            KeyHandle = NULL;
+            printf( " - failed (0x%08x)", Status );
+            }
+        printf( "\n" );
+
+        if (KeyHandle != NULL) {
+            pValue = MP( PIML_VALUE_RECORD, pImlUndo, pKey->Values );
+            while (pValue != NULL) {
+                pOldValue = MP( PIML_VALUE_RECORD_CONTENTS, pImlUndo, pValue->OldValue );
+                pNewValue = MP( PIML_VALUE_RECORD_CONTENTS, pImlUndo, pValue->NewValue );
+                printf( "        %ws - ", MP( PWSTR, pImlUndo, pValue->Name ) );
+                RtlInitUnicodeString( &ValueName,
+                                      MP( PWSTR, pImlUndo, pValue->Name )
+                                    );
+                if (pValue->Action == CreateNewValue) {
+                    printf( "deleting" );
+                    Status = NtDeleteValueKey( KeyHandle, &ValueName );
+                    }
+                else {
+                    if (pValue->Action == DeleteOldValue) {
+                        printf( "creating" );
+                        }
+                    else {
+                        printf( "restoring" );
+                        }
+
+                    Status = NtSetValueKey( KeyHandle,
+                                            &ValueName,
+                                            0,
+                                            pOldValue->Type,
+                                            MP( PWSTR, pImlUndo, pOldValue->Data ),
+                                            pOldValue->Length
+                                          );
+                    }
+
+                if (!NT_SUCCESS( Status )) {
+                    printf( " - failed (0x%08x)", Status );
+                    }
+                printf( "\n" );
+
+                pValue = MP( PIML_VALUE_RECORD, pImlUndo, pValue->Next );
+                }
+            }
+        }
+
+    if (KeyHandle != NULL) {
+        if (pKey->Action == CreateNewKey) {
+            Status = NtDeleteKey( KeyHandle );
+            if (!NT_SUCCESS( Status )) {
+                printf( "    *** delete of above key failed (0x%08x)", Status );
+                }
+            }
+        NtClose( KeyHandle );
+        }
+
+    return TRUE;
+}
+
+
+BOOLEAN
+ProcessRedoKeyIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PIML_KEY_RECORD pKey,
+    PINSTALLATION_MODIFICATION_LOGFILE pImlRedo
+    )
+{
+    PIML_VALUE_RECORD pValue;
+    PIML_VALUE_RECORD_CONTENTS pOldValue;
+    PIML_VALUE_RECORD_CONTENTS pNewValue;
+    POFFSET Values;
+
+    Values = 0;
+    if ((pKey->Values != 0 || pKey->Action == CreateNewKey) &&
+        pKey->Action != DeleteOldKey
+       ) {
+        //
+        // Created or modified an existing key and/or values.
+        //
+        pValue = MP( PIML_VALUE_RECORD, pImlUndo, pKey->Values );
+        while (pValue != NULL) {
+            pOldValue = MP( PIML_VALUE_RECORD_CONTENTS, pImlUndo, pValue->OldValue );
+            pNewValue = MP( PIML_VALUE_RECORD_CONTENTS, pImlUndo, pValue->NewValue );
+            if (pValue->Action == CreateNewValue) {
+                if (pNewValue != NULL) {
+                    ImlAddValueRecord( pImlRedo,
+                                       pValue->Action,
+                                       MP( PWSTR, pImlUndo, pValue->Name ),
+                                       pNewValue->Type,
+                                       pNewValue->Length,
+                                       MP( PWSTR, pImlUndo, pNewValue->Data ),
+                                       0,
+                                       0,
+                                       NULL,
+                                       &Values
+                                     );
+                    }
+                }
+            else
+            if (pValue->Action == ModifyOldValue) {
+                if (pOldValue != NULL && pNewValue != NULL) {
+                    ImlAddValueRecord( pImlRedo,
+                                       pValue->Action,
+                                       MP( PWSTR, pImlUndo, pValue->Name ),
+                                       pNewValue->Type,
+                                       pNewValue->Length,
+                                       MP( PWSTR, pImlUndo, pNewValue->Data ),
+                                       pOldValue->Type,
+                                       pOldValue->Length,
+                                       MP( PWSTR, pImlUndo, pOldValue->Data ),
+                                       &Values
+                                     );
+                    }
+                }
+            else
+            if (pValue->Action == DeleteOldValue) {
+                if (pOldValue != NULL) {
+                    ImlAddValueRecord( pImlRedo,
+                                       pValue->Action,
+                                       MP( PWSTR, pImlUndo, pValue->Name ),
+                                       0,
+                                       0,
+                                       NULL,
+                                       pOldValue->Type,
+                                       pOldValue->Length,
+                                       MP( PWSTR, pImlUndo, pOldValue->Data ),
+                                       &Values
+                                     );
+                    }
+                }
+
+            pValue = MP( PIML_VALUE_RECORD, pImlUndo, pValue->Next );
+            }
+        }
+
+    ImlAddKeyRecord( pImlRedo,
+                     pKey->Action,
+                     MP( PWSTR, pImlUndo, pKey->Name ),
+                     Values
+                   );
+    return TRUE;
+}
+
+BOOLEAN
+ProcessUndoIniIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PIML_INI_RECORD pIni
+    )
+{
+    PIML_INISECTION_RECORD pSection;
+    PIML_INIVARIABLE_RECORD pVariable;
+    HANDLE FileHandle;
+    BOOLEAN FileNameShown;
+    BOOLEAN SectionNameShown;
+
+    FileNameShown = FALSE;
+    pSection = MP( PIML_INISECTION_RECORD, pImlUndo, pIni->Sections );
+    while (pSection != NULL) {
+        SectionNameShown = FALSE;
+        pVariable = MP( PIML_INIVARIABLE_RECORD, pImlUndo, pSection->Variables );
+        while (pVariable != NULL) {
+            if (!FileNameShown) {
+                printf( "%ws\n", MP( PWSTR, pImlUndo, pIni->Name ) );
+                FileNameShown = TRUE;
+                }
+
+            if (!SectionNameShown) {
+                printf( "    [%ws]", MP( PWSTR, pImlUndo, pSection->Name ) );
+                if (pSection->Action == DeleteOldSection) {
+                    printf( " - deleting" );
+                    }
+                printf( "\n" );
+                SectionNameShown = TRUE;
+                }
+
+            printf( "        %ws = ", MP( PWSTR, pImlUndo, pVariable->Name ) );
+            if (pVariable->Action == CreateNewVariable) {
+                printf( "deleting" );
+                if (!WritePrivateProfileString( MP( PWSTR, pImlUndo, pSection->Name ),
+                                                MP( PWSTR, pImlUndo, pVariable->Name ),
+                                                NULL,
+                                                MP( PWSTR, pImlUndo, pIni->Name )
+                                              )
+                   ) {
+                    printf( " - failed (%u)", GetLastError() );
+                    }
+                printf( "\n" );
+                }
+            else {
+                printf( "restoring" );
+                if (!WritePrivateProfileString( MP( PWSTR, pImlUndo, pSection->Name ),
+                                                MP( PWSTR, pImlUndo, pVariable->Name ),
+                                                MP( PWSTR, pImlUndo, pVariable->OldValue ),
+                                                MP( PWSTR, pImlUndo, pIni->Name )
+                                              )
+                   ) {
+                    printf( " - failed (%u)", GetLastError() );
+                    }
+                printf( "\n" );
+                }
+
+            pVariable = MP( PIML_INIVARIABLE_RECORD, pImlUndo, pVariable->Next );
+            }
+
+        if (pSection->Action == CreateNewSection) {
+            if (!FileNameShown) {
+                printf( "%ws\n", MP( PWSTR, pImlUndo, pIni->Name ) );
+                FileNameShown = TRUE;
+                }
+
+            if (!SectionNameShown) {
+                printf( "    [%ws]", MP( PWSTR, pImlUndo, pSection->Name ) );
+                if (pSection->Action == CreateNewSection) {
+                    printf( " - deleting" );
+                    }
+                SectionNameShown = TRUE;
+                printf( "\n" );
+                }
+
+            if (!WritePrivateProfileSection( MP( PWSTR, pImlUndo, pSection->Name ),
+                                             NULL,
+                                             MP( PWSTR, pImlUndo, pIni->Name )
+                                           )
+               ) {
+                printf( "    *** delete of above section name failed (%u)\n",
+                        GetLastError()
+                      );
+                }
+            }
+
+        pSection = MP( PIML_INISECTION_RECORD, pImlUndo, pSection->Next );
+        }
+
+    if (pIni->Action == CreateNewIniFile) {
+        printf( "%ws - deleting", MP( PWSTR, pImlUndo, pIni->Name ) );
+        if (!DeleteFile( MP( PWSTR, pImlUndo, pIni->Name ) )) {
+            printf( " - failed (%u)", GetLastError() );
+            }
+        printf( "\n" );
+        FileNameShown = TRUE;
+        }
+    else {
+        FileHandle = CreateFile( MP( PWSTR, pImlUndo, pIni->Name ),
+                                 FILE_WRITE_ATTRIBUTES,
+                                 FILE_SHARE_READ,
+                                 NULL,
+                                 OPEN_EXISTING,
+                                 0,
+                                 NULL
+                               );
+        if (FileHandle != INVALID_HANDLE_VALUE) {
+            SetFileTime( FileHandle,
+                         &pIni->LastWriteTime,
+                         &pIni->LastWriteTime,
+                         &pIni->LastWriteTime
+                       );
+            CloseHandle( FileHandle );
+            }
+        }
+
+    if (FileNameShown) {
+        printf( "\n" );
+        }
+    return TRUE;
+}
+
+
+BOOLEAN
+ProcessRedoIniIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PIML_INI_RECORD pIni,
+    PINSTALLATION_MODIFICATION_LOGFILE pImlRedo
+    )
+{
+    PIML_INISECTION_RECORD pSection;
+    PIML_INIVARIABLE_RECORD pVariable;
+    POFFSET Variables, Sections;
+
+    pSection = MP( PIML_INISECTION_RECORD, pImlUndo, pIni->Sections );
+    Sections = 0;
+    while (pSection != NULL) {
+        pVariable = MP( PIML_INIVARIABLE_RECORD, pImlUndo, pSection->Variables );
+        Variables = 0;
+        while (pVariable != NULL) {
+            ImlAddIniVariableRecord( pImlRedo,
+                                     pVariable->Action,
+                                     MP( PWSTR, pImlUndo, pVariable->Name ),
+                                     MP( PWSTR, pImlUndo, pVariable->OldValue ),
+                                     MP( PWSTR, pImlUndo, pVariable->NewValue ),
+                                     &Variables
+                                   );
+
+            pVariable = MP( PIML_INIVARIABLE_RECORD, pImlUndo, pVariable->Next );
+            }
+
+        if (Variables != 0) {
+            ImlAddIniSectionRecord( pImlRedo,
+                                    pSection->Action,
+                                    MP( PWSTR, pImlUndo, pSection->Name ),
+                                    Variables,
+                                    &Sections
+                                  );
+            }
+
+        pSection = MP( PIML_INISECTION_RECORD, pImlUndo, pSection->Next );
+        }
+
+    if (Sections != 0) {
+        ImlAddIniRecord( pImlRedo,
+                         pIni->Action,
+                         MP( PWSTR, pImlUndo, pIni->Name ),
+                         &pIni->LastWriteTime,
+                         Sections
+                       );
+        }
+
+    return TRUE;
+}
+
+
+int
+ProcessUndoIml(
+    PINSTALLATION_MODIFICATION_LOGFILE pImlUndo,
+    PINSTALLATION_MODIFICATION_LOGFILE pImlRedo
+    )
+{
+    PIML_FILE_RECORD pFile;
+    PIML_KEY_RECORD pKey;
+    PIML_INI_RECORD pIni;
+
+    if (pImlUndo->NumberOfFileRecords > 0) {
+        printf( "Undoing File Modifications:\n" );
+        pFile = MP( PIML_FILE_RECORD, pImlUndo, pImlUndo->FileRecords );
+        while (pFile != NULL) {
+            if (pFile->Name != 0) {
+                if (pImlRedo != NULL) {
+                    ProcessRedoFileIml( pImlUndo, pFile, pImlRedo );
+                    }
+
+                ProcessUndoFileIml( pImlUndo, pFile );
+                }
+
+            pFile = MP( PIML_FILE_RECORD, pImlUndo, pFile->Next );
+            }
+
+        printf( "\n" );
+        }
+
+    if (pImlUndo->NumberOfKeyRecords > 0) {
+        printf( "Undoing Registry Modifications:\n" );
+        pKey = MP( PIML_KEY_RECORD, pImlUndo, pImlUndo->KeyRecords );
+        while (pKey != NULL) {
+            if (pImlRedo != NULL) {
+                ProcessRedoKeyIml( pImlUndo, pKey, pImlRedo );
+                }
+
+            ProcessUndoKeyIml( pImlUndo, pKey );
+
+            pKey = MP( PIML_KEY_RECORD, pImlUndo, pKey->Next );
+            }
+
+        printf( "\n" );
+        }
+
+    if (pImlUndo->NumberOfIniRecords > 0) {
+        printf( "Undoing .INI File modifications:\n" );
+        pIni = MP( PIML_INI_RECORD, pImlUndo, pImlUndo->IniRecords );
+        while (pIni != NULL) {
+            if (pImlRedo != NULL) {
+                ProcessRedoIniIml( pImlUndo, pIni, pImlRedo );
+                }
+
+            ProcessUndoIniIml( pImlUndo, pIni);
+
+            pIni = MP( PIML_INI_RECORD, pImlUndo, pIni->Next );
+            }
+        }
+
+    return 0;
+}
diff --git a/private/sdktools/instaler/undoinst.rc b/private/sdktools/instaler/undoinst.rc
new file mode 100644
index 000000000..61608cfe0
--- /dev/null
+++ b/private/sdktools/instaler/undoinst.rc
@@ -0,0 +1,12 @@
+#include "instaler.h"
+#include <ntverp.h>
+
+#define	VER_FILETYPE	VFT_APP
+#define	VER_FILESUBTYPE	VFT2_UNKNOWN
+#define VER_FILEDESCRIPTION_STR     "Windows NT Instaler Undo Program"
+#define VER_INTERNALNAME_STR        "UNDOINST\0"
+#define VER_ORIGINALFILENAME_STR    "UNDOINST.EXE"
+
+#include "common.ver"
+
+RCINCLUDE errormsg.rc