windows-server-2003/termsrv/tsappcmp/inimap.c

/*************************************************************************
*
* inimap.c
*
* Handle Copy-On-Reference Ini File Mapping
*
* copyright notice: Copyright 1998 Micrsoft
*
*
*************************************************************************/

#include "precomp.h"
#pragma hdrstop


#define LOCAL
#include "regmap.h"

//#include "basedll.h"

#if DBG
ULONG
DbgPrint(
    PCH Format,
    ...
    );
#define DBGPRINT(x) DbgPrint x
#if DBGTRACE
#define TRACE0(x)   DbgPrint x
#define TRACE1(x)   DbgPrint x
#else
#define TRACE0(x)
#define TRACE1(x)
#endif
#else
#define DBGPRINT(x)
#define TRACE0(x)
#define TRACE1(x)
#endif

#define IS_NEWLINE_CHAR( c )  ((c == 0x0D) || (c == 0x0A))

/*
 *  INI_BUF_SIZE defines the maximum number of characters that can
 *  be on a single INI file line.  If a line contains more than this
 *  number of characters, the additional characters will be lost.
 */
#define INI_BUF_SIZE 1024


/* Internal Functions */

BOOL
TermsrvDoesFileExist(
    PUNICODE_STRING pFileName
    );

BOOL
TermsrvBuildSysIniPath(
    PUNICODE_STRING pIniPath,
    PUNICODE_STRING pSysPath,
    PUNICODE_STRING pUserPath
    );

BOOL
TermsrvCopyIniFile(
    PUNICODE_STRING pSysPath,
    PUNICODE_STRING pUserPath,
    PUNICODE_STRING pFileName
    );

BOOL
TermsrvGetUnicodeRemainder(
    PUNICODE_STRING pFullPath,
    PUNICODE_STRING pPrefix,
    PUNICODE_STRING pRemainder
    );

NTSTATUS
TermsrvIniCopyLoop(
    HANDLE SrcHandle,
    HANDLE DestHandle
    );

NTSTATUS
TermsrvPutString(
    HANDLE DestHandle,
    PCHAR  pStr,
    ULONG  StringSize
    );

NTSTATUS
TermsrvProcessBuffer(
    PCHAR  *ppStr,
    PULONG pStrSize,
    PULONG pStrBufSize,
    PBOOL  pSawNL,
    PCHAR  pIOBuf,
    PULONG pIOBufIndex,
    PULONG pIOBufFillSize
    );

NTSTATUS
TermsrvGetString(
    HANDLE SrcHandle,
    PCHAR  *ppStringPtr,
    PULONG pStringSize,
    PCHAR  pIOBuf,
    ULONG  IOBufSize,
    PULONG pIOBufIndex,
    PULONG pIOBufFillSize
    );

NTSTATUS
TermsrvIniCopyAndChangeLoop(
    HANDLE SrcHandle,
    HANDLE DestHandle,
    PUNICODE_STRING pUserFullPath,
    PUNICODE_STRING pSysFullPath
    );

BOOL
TermsrvReallocateBuf(
    PCHAR  *ppStr,
    PULONG pStrBufSize,
    ULONG  NewSize
    );


PCHAR
Ctxstristr( PCHAR pstring1,
            PCHAR pstring2
          );


NTSTATUS
TermsrvCheckKeys(HANDLE hKeySysRoot,
             HANDLE hKeyUsrRoot,
             PKEY_BASIC_INFORMATION pKeySysInfo,
             PKEY_FULL_INFORMATION pKeyUsrInfo,
             ULONG ulcsys,
             ULONG ulcusr,
             DWORD  indentLevel);

NTSTATUS
TermsrvCloneKey(HANDLE hKeySys,
            HANDLE hKeyUsr,
            PKEY_FULL_INFORMATION pDefKeyInfo,
            BOOL fCreateSubKeys);

VOID
InitUnicodeStringWithLen(
    OUT PUNICODE_STRING DestinationString,
    IN PCWSTR SourceString,
    IN USHORT StringLength
    );

void TermsrvCheckNewRegEntries(IN LPCWSTR wszBaseKeyName);

BOOL
TermsrvGetUserSyncTime(PULONG pultime);

BOOL
TermsrvSetUserSyncTime(void);

NTSTATUS 
TermsrvCheckNewIniFilesInternal(IN LPCWSTR wszBaseKeyName);

NTSTATUS 
GetFullKeyPath(
        IN HANDLE hKeyParent,
        IN LPCWSTR wszKey,
        OUT LPWSTR *pwszKeyPath);

PWINSTATIONQUERYINFORMATIONW pWinStationQueryInformationW;

DWORD g_debugIniMap=FALSE;

DWORD IsDebugIniMapEnabled()
{
    HKEY    hKey;
    DWORD   rc;
    DWORD   res=0;
    DWORD   size;

    rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Terminal Server\\Install",
                  0, KEY_READ, &hKey );

    size = sizeof(DWORD);

    if (rc == ERROR_SUCCESS )
    {
        rc = RegQueryValueEx( hKey, L"debug",  NULL , NULL , (LPBYTE ) &res, & size  ) ;

        if (rc != ERROR_SUCCESS )
        {
            res = FALSE;
        }
        RegCloseKey( hKey );
    }

    return res;
}

void    Indent( ULONG indent)
{
    ULONG   i;
    for ( i = 1; i <indent ; i++ )
    {
        DbgPrint("%ws", L"\t");
    }
}

// last param is a unicode string
void Debug1( DWORD indent, DWORD line, WCHAR *where, UNICODE_STRING *pS )
{
    WCHAR   s[1024];

    if (g_debugIniMap)
    {
        wcsncpy( s, pS->Buffer, pS->Length );
    
        s[pS->Length + 1 ] = L'\0';
    
        Indent( indent );
        DbgPrint("L: %4d, %10ws: %ws \n", line, where, s );
    }

}


// last param two params, one is the wchar str and the last one is the length. Boy I miss c++ and func overloading...
void Debug2( DWORD indent, DWORD line, WCHAR *where, WCHAR *pS , DWORD length)
{
    WCHAR   s[1024];

    if (g_debugIniMap)
    {
        wcsncpy( s, pS, length );
    
        s[length + 1 ] = L'\0';
    
        Indent( indent );
        DbgPrint("L: %4d, %10ws: %ws \n", line, where, s );
    }

}

void DebugTime( DWORD indent, DWORD line, WCHAR *comment, LARGE_INTEGER li )
{
    if (g_debugIniMap)
    {
        Indent( indent );
        DbgPrint("L: %4d, %5ws : %I64x \n",  line , comment , li.QuadPart );
    }
}

/*****************************************************************************
 *
 *  TermsrvGetUserSyncTime
 *
 *  This routine will get the last time we sync'd up this user's .ini files
 *  and registry values with the system versions.
 *
 * ENTRY:
 *   PULONG pultime: pointer to receive last sync time (in seconds since 1970)
 *
 * EXIT:
 *   SUCCESS:
 *      returns TRUE
 *   FAILURE:
 *      returns FALSE
 *
 ****************************************************************************/

BOOL TermsrvGetUserSyncTime(PULONG pultime)
{
    ULONG ullen, ultmp;
    NTSTATUS Status;
    HANDLE hKey, hKeyRoot;
    OBJECT_ATTRIBUTES ObjectAttr;
    PKEY_VALUE_PARTIAL_INFORMATION pKeyValInfo;
    UNICODE_STRING UniString, UserSID;
    PWCHAR pwch;

    // Allocate a buffer for the key value name and time info
    ullen = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + sizeof(ULONG);
    pKeyValInfo = RtlAllocateHeap(RtlProcessHeap(),
                                  0,
                                  ullen);

    // If we didn't get the buffer, return
    if (!pKeyValInfo) {
        return(FALSE);
    }

    Status = RtlOpenCurrentUser(KEY_READ,
                                &hKeyRoot);

    if (NT_SUCCESS(Status)) {

        // Now open up the Citrix key for this user
        RtlInitUnicodeString(&UniString,
                             USER_SOFTWARE_TERMSRV);

        InitializeObjectAttributes(&ObjectAttr,
                                   &UniString,
                                   OBJ_CASE_INSENSITIVE,
                                   hKeyRoot,
                                   NULL);

        Status = NtCreateKey(&hKey,
                             KEY_READ,
                             &ObjectAttr,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             &ultmp);

        NtClose(hKeyRoot);
    }

    // If we opened the key, and it was already there, get the value
    if (NT_SUCCESS(Status) && (ultmp == REG_OPENED_EXISTING_KEY)) {
        RtlInitUnicodeString(&UniString, TERMSRV_USER_SYNCTIME);
        Status = NtQueryValueKey(hKey,
                                 &UniString,
                                 KeyValuePartialInformation,
                                 pKeyValInfo,
                                 ullen,
                                 &ultmp);

        NtClose(hKey);
        if (NT_SUCCESS(Status)) {
            *pultime = *(PULONG)pKeyValInfo->Data;
        }
    } else {
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
    }

    RtlFreeHeap( RtlProcessHeap(), 0, pKeyValInfo );
    return(NT_SUCCESS(Status));
}


/*****************************************************************************
 *
 *  TermsrvSetUserSyncTime
 *
 *  This routine will set the current time as this user's last .ini file
 *  sync time.
 *
 * ENTRY:
 *
 * EXIT:
 *   SUCCESS:
 *      returns TRUE
 *   FAILURE:
 *      returns FALSE
 *
 ****************************************************************************/

BOOL TermsrvSetUserSyncTime(void)
{
    ULONG ultmp;
    NTSTATUS Status;
    HANDLE hKey, hKeyRoot;
    OBJECT_ATTRIBUTES ObjectAttr;
    UNICODE_STRING UniString;
    PWCHAR pwch;
    FILETIME FileTime;

    Status = RtlOpenCurrentUser(KEY_WRITE,
                                &hKeyRoot);

    if (NT_SUCCESS(Status)) {

        // Now open up the Citrix key for this user
        RtlInitUnicodeString(&UniString,
                             USER_SOFTWARE_TERMSRV);

        InitializeObjectAttributes(&ObjectAttr,
                                   &UniString,
                                   OBJ_CASE_INSENSITIVE,
                                   hKeyRoot,
                                   NULL);

        Status = NtCreateKey(&hKey,
                             KEY_WRITE,
                             &ObjectAttr,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             &ultmp);
        NtClose(hKeyRoot);
    }

    // If we opened the key, and set the sync time value
    if (NT_SUCCESS(Status)) {
        // Get the system time, convert to local time, and convert to seconds
        GetSystemTimeAsFileTime(&FileTime);
        RtlTimeToSecondsSince1970((PLARGE_INTEGER)&FileTime,
                                  &ultmp);

        RtlInitUnicodeString(&UniString,
                             TERMSRV_USER_SYNCTIME);

        // Now store it under the citrix key in the registry
        Status = NtSetValueKey(hKey,
                               &UniString,
                               0,
                               REG_DWORD,
                               &ultmp,
                               sizeof(ultmp));

        NtClose(hKey);
    } else {
        Status = STATUS_OBJECT_NAME_NOT_FOUND;
    }

    return(NT_SUCCESS(Status));
}



/*****************************************************************************
 *
 *  TermsrvCORIniFile
 *
 *   Copy On Reference an Ini file
 *
 *   This function is called to copy an ini file from the system
 *   directory to a users local ini file directory.
 *
 *   The path supplied is the fully translated TERMSRV INI file path,
 *   whichs points to a users directory.
 *
 *   This string is used to find the system ini file, and copy it to the
 *   users directory.
 *
 *   All paths are NT paths, NOT WIN32 paths.
 *
 *   Example:
 *
 *   \DosDevices\U:\users\default\windows\win.ini is the path given
 *
 *   %SystemRoot%\win.ini is the "default" location with ini mapping off.
 *
 *   If \DosDevices\U:\users\default\windows\win.ini does not exist, test to see if
 *   %SystemRoot%\win.ini exists, and if does, copy the system version
 *   to the users directory.
 *
 *   NOTE: If the path is to the normal unmapped system directory, just
 *         return since there is no mapping occuring.
 *
 * ENTRY:
 *   pUserFullPath (input)
 *     Translated TERMSRV INI path name
 *
 * EXIT:
 *
 ****************************************************************************/

VOID
TermsrvCORIniFile(
    PUNICODE_STRING pUserFullPath
    )
{
    DWORD Result;
    BOOL  rc;
    UNICODE_STRING SysFullPath;
    UNICODE_STRING UserBasePath;

    /*
     * If in install mode, just return to make
     * everything behave as stock NT.
     */
    if ( IsSystemLUID() || TermsrvAppInstallMode() ) {
        TRACE0(("TermsrvCORIniFile: INI file mapping is OFF\n"));
        return;
    }

    if (!TermsrvPerUserWinDirMapping()) {
        return;
    }

    /*
     * If a NULL file name, just return
     */
    if( (pUserFullPath == NULL) || (pUserFullPath->Buffer == NULL) ) {
        TRACE0(("TermsrvCORIniFile: NULL File INI file name\n"));
        return;
    }

    /*
     * Test if user file exists
     */
    if( TermsrvDoesFileExist( pUserFullPath ) ) {

        TRACE0(("TermsrvCORIniFile: File %ws Exists\n",pUserFullPath->Buffer));
        //
        // Nothing to do if the user already has a copy
        //
        return;
    }
    else {
        TRACE0(("TermsrvCORIniFile: File %ws DOES NOT Exist!\n",pUserFullPath->Buffer));
    }

    /*
     * The requested ini file does not exist in the users local
     * directory. We must change the path name to point to the system
     * directory, and test if the ini file exists there.
     */

    /*
     * Build full system path to the Ini file.
     *
     * This also parses out the users base path and returns that as well.
     */
    if( !TermsrvBuildSysIniPath( pUserFullPath, &SysFullPath, &UserBasePath ) ) {

        TRACE0(("TermsrvCORIniFile: Error building Sys Ini Path!\n"));
        return;
    }

    /*
     * Test if system version exists
     */
    if( !TermsrvDoesFileExist( &SysFullPath ) ) {
        //
        // It does not exist in the system directory either,
        // so we just return.
        //
        TRACE0(("TermsrvCORIniFile: Path %ws does not exist in system dir, Length %d\n",SysFullPath.Buffer,SysFullPath.Length));
        TRACE0(("TermsrvCORIniFile: UserPath %ws\n",pUserFullPath->Buffer));
        RtlFreeHeap( RtlProcessHeap(), 0, SysFullPath.Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, UserBasePath.Buffer );
        return;
    }

    /*
     * Now Copy it.
     *
     * The copy routine could also translate any paths internal to the
     * ini file that point to the system directory, to point to the user
     * directory in the base path.
     */
    rc = TermsrvCopyIniFile( &SysFullPath, &UserBasePath, pUserFullPath);

#if DBG
    if( !rc ) {
        DBGPRINT(("TermsrvCORIniFile: Could not copy file %ws to %ws\n",SysFullPath.Buffer,pUserFullPath->Buffer));
    }
#endif

    RtlFreeHeap( RtlProcessHeap(), 0, SysFullPath.Buffer );
    RtlFreeHeap( RtlProcessHeap(), 0, UserBasePath.Buffer );

    return;
}


/*****************************************************************************
 *
 *  TermsrvDoesFileExist
 *
 *   Returns whether the file exists or not.
 *
 *   Must use NT, not WIN32 pathnames.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

BOOL
TermsrvDoesFileExist(
    PUNICODE_STRING pFileName
    )
{
    NTSTATUS Status;
    FILE_BASIC_INFORMATION BasicInfo;
    OBJECT_ATTRIBUTES Obja;

    InitializeObjectAttributes(
        &Obja,
        pFileName,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
        );

    /*
     * Now query it
     */
    Status = NtQueryAttributesFile( &Obja, &BasicInfo );

    if( NT_SUCCESS( Status ) ) {
        return( TRUE );
    }

    return( FALSE );
}


/*****************************************************************************
 *
 *  TermsrvBuildSysIniPath
 *
 *   Builds the full ini path to pointing to the system directory
 *   from the users private ini path.
 *
 *   Also returns the users base ini path directory to be used by
 *   the ini file path conversion when copying.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

BOOL
TermsrvBuildSysIniPath(
    PUNICODE_STRING pUserFullPath,
    PUNICODE_STRING pSysFullPath,
    PUNICODE_STRING pUserBasePath
    )
{
    BOOL     rc = FALSE;
    NTSTATUS Status;
    UNICODE_STRING SysBasePath;
    UNICODE_STRING IniPathTail;
    UNICODE_STRING UniSysDir;
    WCHAR CtxWindowsPath[MAX_PATH+1];
    UNICODE_STRING CtxWindowsDir = {
        sizeof(CtxWindowsPath),
        sizeof(CtxWindowsPath),
        CtxWindowsPath
    };
    OBJECT_ATTRIBUTES ObjectAttr;
    HKEY   hKey = 0;
    ULONG  ul;
    PKEY_VALUE_FULL_INFORMATION pKeyValInfo;
    WCHAR SystemWindowsDirectory[MAX_PATH+1];

    if (!TermsrvPerUserWinDirMapping()) {
        return FALSE;
    }

    SysBasePath.Buffer = NULL;

    pKeyValInfo = RtlAllocateHeap(RtlProcessHeap(),
                                  0,
                                  sizeof(KEY_VALUE_FULL_INFORMATION) + MAX_PATH
                                 );
    if (pKeyValInfo) {
        RtlInitUnicodeString(&UniSysDir,
                             TERMSRV_COMPAT
                            );

        InitializeObjectAttributes(&ObjectAttr,
                                   &UniSysDir,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL
                                  );

        Status = NtOpenKey(&hKey, KEY_READ, &ObjectAttr);

        if (NT_SUCCESS(Status)) {

            RtlInitUnicodeString(&UniSysDir, L"SYSDIR");
            Status = NtQueryValueKey(hKey,
                                     &UniSysDir,
                                     KeyValueFullInformation,
                                     pKeyValInfo,
                                     sizeof(KEY_VALUE_FULL_INFORMATION) +
                                         MAX_PATH,
                                     &ul
                                    );

            if (NT_SUCCESS(Status)) {
                NtClose(hKey);

                if (ul = wcslen((PWCHAR)((PCHAR)pKeyValInfo +
                                    pKeyValInfo->DataOffset))) {

                    RtlInitUnicodeString(&UniSysDir,
                                         (PWCHAR)((PCHAR)pKeyValInfo +
                                             pKeyValInfo->DataOffset)
                                        );

                    // Convert to an NT path
                    rc = RtlDosPathNameToNtPathName_U(
                             UniSysDir.Buffer,
                             &SysBasePath,
                             NULL,
                             NULL
                            );

                    // Was this a valid path?  If not, use actual system directory.
                    if (rc && !TermsrvDoesFileExist(&SysBasePath)) {
                        RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
                        SysBasePath.Buffer = NULL;
                        rc = FALSE;
                    }

                    // if the path is the root, get rid of last backslash
                    if (ul == 3 && SysBasePath.Buffer) {
                        SysBasePath.Buffer[SysBasePath.Length/sizeof(WCHAR)] = L'\0';
                        SysBasePath.Length -= 2;
                    }
                }
            }
        }
    }

    GetSystemWindowsDirectory(SystemWindowsDirectory,(MAX_PATH * sizeof(WCHAR)));

    if (!rc) {

        /*
         * We must convert the SystemWindowsDirectory from a WIN32 path to
         * an NT path.
         */
        rc = RtlDosPathNameToNtPathName_U( SystemWindowsDirectory,
                                           &SysBasePath,
                                           NULL,
                                           NULL
                                         );
    }

    if (pKeyValInfo) {
        RtlFreeHeap( RtlProcessHeap(), 0, pKeyValInfo );
    }

    TRACE0(("BaseWindowsDirectory is %ws\n",SystemWindowsDirectory));

    if( !rc ) {
        DBGPRINT(("BuildSysIniPath: Error translating system path to NT path %ws\n",SystemWindowsDirectory));
        return( FALSE );
    }

    TRACE0(("BuildSysIniPath: NT SYS path is %ws\n",SysBasePath.Buffer));

    /*
     * Get the users windows path prefix
     */
    Status = GetPerUserWindowsDirectory( &CtxWindowsDir );
    if( !NT_SUCCESS( Status ) ) {
        DBGPRINT(("BuildSysIniPath: Could not get TermsrvWindowsDir 0x%x\n",Status));
        RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
        return( FALSE );
    }

    /*
     * Now convert it into an NT path
     */
    rc = RtlDosPathNameToNtPathName_U(
             CtxWindowsDir.Buffer,
             pUserBasePath,
             NULL,
             NULL
             );

    if( !rc ) {
        DBGPRINT(("BuildSysIniPath: Could not convert TermsrvWindowsDir %d\n",rc));
        RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
        return( FALSE );
    }

    TRACE0(("BuildSysIniPath: Users Ini PathBase is %ws\n",pUserBasePath->Buffer));

    //
    // Here we have:
    //
    // SysBasePath, UserBasePath
    //
    // UserFullPath, must now build SysFullPath
    //

    rc = TermsrvGetUnicodeRemainder( pUserFullPath, pUserBasePath, &IniPathTail );

    if( !rc ) {
        WCHAR szShortPath[MAX_PATH];
        WCHAR szPath[MAX_PATH];
        UNICODE_STRING ShortPath;

        //
        // GetShortPathName doesn't take NT Path. Strip out "\??\"
        //
        if (!wcsncmp(pUserBasePath->Buffer,L"\\??\\",4)) {
            wcsncpy(szPath,&(pUserBasePath->Buffer[4]),(pUserBasePath->Length - 4));
        } else {
            wcsncpy(szPath,pUserBasePath->Buffer,pUserBasePath->Length);
        }
        if (GetShortPathNameW(szPath,szShortPath,MAX_PATH)) {

            if (!wcsncmp(pUserBasePath->Buffer,L"\\??\\",4)) {
                wcscpy(szPath,L"\\??\\");
                wcscat(szPath,szShortPath);
            } else {
                wcscpy(szPath,szShortPath);
            }

            RtlInitUnicodeString(&ShortPath,szPath);
            rc = TermsrvGetUnicodeRemainder( pUserFullPath, &ShortPath, &IniPathTail );
        }

        if (!rc) {
            RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
            RtlFreeHeap( RtlProcessHeap(), 0, pUserBasePath->Buffer );
            return( FALSE );
        }
    }

    pSysFullPath->Length = 0;
    pSysFullPath->MaximumLength = (MAX_PATH+1)*sizeof(WCHAR);
    pSysFullPath->Buffer = RtlAllocateHeap( RtlProcessHeap(), 0, pSysFullPath->MaximumLength );

    if( pSysFullPath->Buffer == NULL ) {
        DBGPRINT(("BuildSysPath: Error in memory allocate\n"));
        RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, IniPathTail.Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, pUserBasePath->Buffer );
        return( FALSE );
    }

    TRACE0(("BuildSysPath: IniPathTail :%ws:, Length %d\n",IniPathTail.Buffer,IniPathTail.Length));
    RtlCopyUnicodeString( pSysFullPath, &SysBasePath );

     if ((pSysFullPath->Buffer[pSysFullPath->Length/sizeof(WCHAR) -1 ] != L'\\') &&
        (IniPathTail.Buffer[0] != L'\\')) {     // check whether need "\\"
        Status = RtlAppendUnicodeToString(pSysFullPath, L"\\");
        if ( !NT_SUCCESS( Status) ) {
            DBGPRINT(("BuildSysPath: Error appending UnicodeStirng\n",Status));
            return( FALSE );
        }
     }

    Status = RtlAppendUnicodeStringToString( pSysFullPath, &IniPathTail );

    if( !NT_SUCCESS( Status ) ) {
        DBGPRINT(("BuildSysPath: Error 0x%x appending UnicodeString\n",Status));
        RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, IniPathTail.Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, pUserBasePath->Buffer );
        RtlFreeHeap( RtlProcessHeap(), 0, pSysFullPath->Buffer );
        return( FALSE );
    }

    TRACE0(("BuildSysPath: SysFullPath :%ws:, Length %d\n",pSysFullPath->Buffer,pSysFullPath->Length));

    /*
     * Free the local resources allocated
     */
    RtlFreeHeap( RtlProcessHeap(), 0, SysBasePath.Buffer );
    RtlFreeHeap( RtlProcessHeap(), 0, IniPathTail.Buffer );

    return( TRUE );
}


/*****************************************************************************
 *
 *  TermsrvGetUnicodeRemainder
 *
 *   Given the full path, and a prefix, return the remainder of
 *   the UNICODE_STRING in newly allocated buffer space.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   TRUE  - no error
 *   FALSE - error
 *
 ****************************************************************************/

BOOL
TermsrvGetUnicodeRemainder(
    PUNICODE_STRING pFullPath,
    PUNICODE_STRING pPrefix,
    PUNICODE_STRING pRemainder
    )
{
    WCHAR c1, c2;
    USHORT Index, RemIndex;
    USHORT PathLen, PrefixLen, RemLen;

    PathLen = pFullPath->Length / sizeof(WCHAR);
    PrefixLen = pPrefix->Length / sizeof(WCHAR);

    if( (PathLen == 0) || (PrefixLen == 0) ) {
        TRACE1(("TermsrvGetUnicodeRemainder: 0 PathLength Full %d, Prefix %d\n",PathLen,PrefixLen));
        return( FALSE );
    }

    Index = 0;
    while( PathLen && PrefixLen ) {

        c1 = pFullPath->Buffer[Index];
        c2 = pPrefix->Buffer[Index];

        // Do a fast case insensitive compare
        if( (c1 != c2) && (towupper(c1) != towupper(c2)) ) {
            TRACE1(("TermsrvGetUnicodeRemainder: Non matching character Index %d\n",Index));
            return( FALSE );
        }

        PathLen--;
        PrefixLen--;
        Index++;
    }

    // If prefix is longer, its an error
    if( PrefixLen ) {
        TRACE1(("TermsrvGetUnicodeRemainder: Prefix is longer\n"));
        return(FALSE);
    }

    // If PathLen is 0, there is no remainder.
    if( PathLen == 0 ) {
        RemLen = 0;
    }
    else {
        RemLen = PathLen;
    }

    // Allocate memory for remainder, including a UNICODE_NULL
    pRemainder->Length = RemLen*sizeof(WCHAR);
    pRemainder->MaximumLength = (RemLen+1)*sizeof(WCHAR);
    pRemainder->Buffer = RtlAllocateHeap( RtlProcessHeap(), 0, pRemainder->MaximumLength );
    if( pRemainder->Buffer == NULL ) {
        TRACE1(("TermsrvGetUnicodeRemainder: Memory allocation error\n"));
        return( FALSE );
    }

    RemIndex  = 0;
    while( RemLen ) {

        pRemainder->Buffer[RemIndex] = pFullPath->Buffer[Index];

        Index++;
        RemIndex++;
        RemLen--;
    }

    // Now include the UNICODE_NULL
    pRemainder->Buffer[RemIndex] = UNICODE_NULL;

    TRACE0(("TermsrvGetUnicodeRemainder: Remainder %ws\n",pRemainder->Buffer));

    return( TRUE );
}


/*****************************************************************************
 *
 *  TermsrvCopyIniFile
 *
 *   Copies the INI file from the system directory to the
 *   users directory.
 *
 *   Any paths inside the INI file that match pUserBasePath and do not point
 *   to a shareable application resource will be translated.
 *
 * ENTRY:
 *  PUNICODE_STRING pSysFullPath (In)  - Path of ini file in system dir (source)
 *  PUNICODE_STRING pUserBasePath (In) - Optional, User's windows home dir
 *  PUNICODE_STRING pUserFullPath (In) - Path of ini file in user's home dir (dest)
 *
 * Notes:
 *  If pUserBasePath is NULL, no path substitution is done as the ini file is
 *  copied from the system directory to the user's home directory.
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

BOOL
TermsrvCopyIniFile(
    PUNICODE_STRING pSysFullPath,
    PUNICODE_STRING pUserBasePath,
    PUNICODE_STRING pUserFullPath
    )
{
    NTSTATUS Status;
    HANDLE SrcHandle, DestHandle;
    OBJECT_ATTRIBUTES SrcObja;
    OBJECT_ATTRIBUTES DestObja;
    IO_STATUS_BLOCK   SrcIosb;
    IO_STATUS_BLOCK   DestIosb;
    PWCHAR            pwch, pwcIniName;
    ULONG             ulCompatFlags;

    TRACE0(("TermsrvCopyIniFile: From %ws, TO -> %ws\n",pSysFullPath->Buffer,pUserFullPath->Buffer));
    TRACE0(("UserBasePath %ws\n",pUserBasePath->Buffer));

    /*
     * This must all be done at the NT level
     */
    InitializeObjectAttributes(
        &SrcObja,
        pSysFullPath,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
        );

    InitializeObjectAttributes(
        &DestObja,
        pUserFullPath,
        OBJ_CASE_INSENSITIVE,
        NULL,
        NULL
        );

    // Open the src
    SrcIosb.Status = STATUS_SUCCESS;
    Status = NtOpenFile(
                 &SrcHandle,
                 FILE_GENERIC_READ,
                 &SrcObja,
                 &SrcIosb,
                 FILE_SHARE_READ|FILE_SHARE_WRITE,
                 FILE_SYNCHRONOUS_IO_NONALERT    // OpenOptions
                 );

    if( NT_SUCCESS(Status) ) {
        // Get final I/O status
        Status = SrcIosb.Status;
    }

    if( !NT_SUCCESS(Status) ) {
        DBGPRINT(("TermsrvCopyIniFile: Error 0x%x opening SrcFile %ws\n",Status,pSysFullPath->Buffer));
        return( FALSE );
    }

    // Create the destination file
    DestIosb.Status = STATUS_SUCCESS;
    Status = NtCreateFile(
                 &DestHandle,
                 FILE_READ_DATA | FILE_WRITE_DATA | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                 &DestObja,
                 &DestIosb,
                 NULL,        // Allocation size
                 FILE_ATTRIBUTE_NORMAL, // dwFlagsAndAttributes
                 FILE_SHARE_WRITE,      // dwShareMode
                 FILE_OVERWRITE_IF,           // CreateDisposition
                 FILE_SYNCHRONOUS_IO_NONALERT | FILE_NON_DIRECTORY_FILE, // CreateFlags
                 NULL, // EaBuffer
                 0     // EaLength
                 );

    if( NT_SUCCESS(Status) ) {
        // Get final I/O status
        Status = DestIosb.Status;
    }

    if( !NT_SUCCESS(Status) ) {
        DBGPRINT(("TermsrvCopyIniFile: Error 0x%x Creating DestFile %ws\n",Status,pUserFullPath->Buffer));
        NtClose( SrcHandle );
        return( FALSE );
    }

    TRACE0(("TermsrvCopyFile: Create Disposition 0x%x\n",DestIosb.Information));

    // Get the ini file name
    pwch = wcsrchr(pSysFullPath->Buffer, L'\\') + 1;
    pwcIniName = RtlAllocateHeap( RtlProcessHeap(),
                                  0,
                                  (wcslen(pwch) + 1)*sizeof(WCHAR));
    if(!pwcIniName)
    {
        DBGPRINT(("TermsrvCopyIniFile: Error Allocating pwcIniName\n"));
        NtClose( SrcHandle );
        NtClose( DestHandle );
        return( FALSE );
    }

    wcscpy(pwcIniName, pwch);
    pwch = wcsrchr(pwcIniName, L'.');
    if (pwch) {
        *pwch = L'\0';
    }

    GetTermsrCompatFlags(pwcIniName, &ulCompatFlags, CompatibilityIniFile);

    RtlFreeHeap( RtlProcessHeap(), 0, pwcIniName );

    /*
     * Now do the copy loop
     */
    if (pUserBasePath && !(ulCompatFlags & TERMSRV_COMPAT_ININOSUB)) {
        Status = TermsrvIniCopyAndChangeLoop( SrcHandle,
                                          DestHandle,
                                          pUserBasePath,
                                          pSysFullPath
                                        );
    } else {
        Status = TermsrvIniCopyLoop( SrcHandle, DestHandle );
    }

    if( !NT_SUCCESS(Status) ) {
        DBGPRINT(("TermsrvCopyIniFile: Error 0x%x Doing copy loop\n",Status));
        NtClose( SrcHandle );
        NtClose( DestHandle );
        return( FALSE );
    }

    /*
     * Close the file handles
     */
    NtClose( SrcHandle );
    NtClose( DestHandle );

    return( TRUE );
}

/*****************************************************************************
 *
 *  TermsrvIniCopyLoop
 *
 *   Actual copy loop. This copies the src ini file to the destination
 *   ini file.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

NTSTATUS
TermsrvIniCopyLoop(
    HANDLE SrcHandle,
    HANDLE DestHandle
    )
{
    NTSTATUS Status;
    PCHAR  pBuf = NULL;
    IO_STATUS_BLOCK   Iosb;

    pBuf = LocalAlloc( LPTR, INI_BUF_SIZE );
    if ( !pBuf ) {
        Status = STATUS_INSUFFICIENT_RESOURCES;
        goto Cleanup;
    }

    while( 1 ) {

        Iosb.Status = STATUS_SUCCESS;
        Status = NtReadFile(
                     SrcHandle,
                     NULL,      // Event
                     NULL,      // APC routine
                     NULL,      // APC context
                     &Iosb,
                     pBuf,
                     INI_BUF_SIZE,
                     NULL,      // ByteOffset (not used since in synchronous I/O)
                     NULL       // Key
                     );

        if( Status == STATUS_PENDING ) {
            Status = NtWaitForSingleObject( SrcHandle, FALSE, NULL );
        }

        if( NT_SUCCESS(Status) ) {
            // Get final I/O status
            Status = Iosb.Status;
        }

        if( !NT_SUCCESS(Status) ) {
            if( Status == STATUS_END_OF_FILE ) {
                Status = STATUS_SUCCESS;
                goto Cleanup;
            }
            DBGPRINT(("TermsrvIniCopyLoop: Error 0x%x doing NtReadFile\n",Status));
            goto Cleanup;
        }

        Iosb.Status = STATUS_SUCCESS;
        Status = NtWriteFile(
                     DestHandle,
                     NULL,      // Event
                     NULL,      // APC routine
                     NULL,      // APC context
                     &Iosb,
                     pBuf,
                     (ULONG)Iosb.Information,  // Actual amount read
                     NULL,      // ByteOffset (not used since in synchronous I/O)
                     NULL       // Key
                     );

        if( Status == STATUS_PENDING ) {
            Status = NtWaitForSingleObject( DestHandle, FALSE, NULL );
        }

        if( NT_SUCCESS(Status) ) {
            // Get final I/O status
            Status = Iosb.Status;
        }

        if( !NT_SUCCESS(Status) ) {
            DBGPRINT(("TermsrvIniCopyLoop: Error 0x%x doing NtWriteFile\n",Status));
            goto Cleanup;
        }

    } // end while(1)

Cleanup:

    if ( pBuf ) {
        LocalFree( pBuf );
    }
    return( Status );
}

/*****************************************************************************
 *
 *  TermsrvIniCopyAndChangeLoop
 *
 *   Actual copy loop. This copies the src ini file to the destination
 *   ini file. It also handles any path translations.
 *
 * ENTRY:
 *  HANDLE SrcHandle (In) - Source file handle
 *  HANDLE DestHandle (In) - Destination file handle
 *  PUNICODE_STRING pUserFullPath (In) - Ptr to Uni string with user's home
 *                                       windows dir
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

NTSTATUS
TermsrvIniCopyAndChangeLoop(
    HANDLE SrcHandle,
    HANDLE DestHandle,
    PUNICODE_STRING pUserFullPath,
    PUNICODE_STRING pSysFullPath
    )
{
    PCHAR pStr, pch, ptemp, pnext;
    PWCHAR pwch;
    NTSTATUS Status;
    ULONG StringSize;
    CHAR  IOBuf[512];
    ULONG IOBufSize = 512;
    ULONG IOBufIndex = 0;
    ULONG IOBufFillSize = 0;
    ANSI_STRING AnsiUserDir, AnsiSysDir;
    UNICODE_STRING UniString;

    // Get the DOS filename from the NT file name
    if (pwch = wcschr(pUserFullPath->Buffer, L':')) {
        pwch--;
    } else {
        pwch = pUserFullPath->Buffer;
    }

    RtlInitUnicodeString( &UniString, pwch );

    Status = RtlUnicodeStringToAnsiString( &AnsiUserDir,
                                           &UniString,
                                           TRUE
                                         );
    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("TermsrvIniCopyAndChangeLoop: Error 0x%x converting user dir\n", Status));
        return(Status);
    }

    // Get the system directory from the fully qualified system path
    if (pwch = wcschr(pSysFullPath->Buffer, L':')) {
        pwch--;
    } else {
        pwch = pUserFullPath->Buffer;
    }

    RtlInitUnicodeString( &UniString, pwch );

    Status = RtlUnicodeStringToAnsiString( &AnsiSysDir,
                                           &UniString,
                                           TRUE
                                         );

    if (!NT_SUCCESS(Status)) {
        DBGPRINT(("TermsrvIniCopyAndChangeLoop: Error 0x%x converting system dir\n", Status));
        RtlFreeAnsiString( &AnsiUserDir );
        return(Status);
    }

    pch = strrchr(AnsiSysDir.Buffer, '\\');

    // unless something has gone wrong, we should always have a pch since a full-path always
    // has at least "\" in it, and actually in our case, we have atleast two slashes inside,
    // since we are dealing with a string such as "\A\file.ini", where 'A' is a folder
    // name that has at least one letter in it
    if (pch)
    {

        if ((pch - AnsiSysDir.Buffer) > 2) {
            *pch = '\0';
        } else {
            *(pch+1) = '\0';
        }
        AnsiSysDir.Length = (USHORT) strlen(AnsiSysDir.Buffer);

        while( 1 ) {

            pStr = NULL;
            StringSize = 0;

            /*
             * Get a string from the source ini file
             */
            Status = TermsrvGetString(
                         SrcHandle,
                         &pStr,
                         &StringSize,
                         IOBuf,
                         IOBufSize,
                         &IOBufIndex,
                         &IOBufFillSize
                         );

            if( !NT_SUCCESS(Status) ) {

                ASSERT( pStr == NULL );

                RtlFreeAnsiString( &AnsiUserDir );
                RtlFreeAnsiString( &AnsiSysDir );

                if( Status == STATUS_END_OF_FILE ) {
                    return( STATUS_SUCCESS );
                }
                return( Status );
            }

            /*
             * Process the string for any ini path translations
             */
            ASSERT( pStr != NULL );

            // Go through the string looking for anything that contains the system
            // directory.
            if (pch = Ctxstristr(pStr, AnsiSysDir.Buffer)) {
                // See if this entry might point to an ini file
                if ((ptemp = strchr(pch, '.')) && !(_strnicmp(ptemp, ".ini", 4))) {

                    // Check to make sure this is the right string to replace
                    pnext = pch + AnsiSysDir.Length + 1;
                    while (pch && (pnext < ptemp)) {
                        // Check for another entry
                        if (*pnext == ',') {
                            pch = Ctxstristr(pnext, AnsiSysDir.Buffer);
                            if (pch) {
                                pnext = pch + AnsiSysDir.Length + 1;
                            }
                        }
                        pnext++;
                    }

                    // Check that this .ini is in the system directory
                    pnext = pch + AnsiSysDir.Length + 1;
                    while (pch && (pnext < ptemp)) {
                        if (*pnext == '\\') {
                            pch = NULL;
                        }
                        pnext++;
                    }

                    if (pch && (pch < ptemp)) {
                        ptemp = RtlAllocateHeap( RtlProcessHeap(),
                                                 0,
                                                 StringSize + AnsiUserDir.Length );
                        strncpy(ptemp, pStr, (size_t)(pch - pStr));       // copy up to sys dir
                        ptemp[pch - pStr] = '\0';
                        strcat(ptemp, AnsiUserDir.Buffer);      // subst user dir
                        if (AnsiSysDir.Length == 3) {
                            strcat(ptemp, "\\");
                        }
                        strcat(ptemp, pch + AnsiSysDir.Length); // append rest of line
                        RtlFreeHeap( RtlProcessHeap(), 0, pStr );
                        StringSize = strlen(ptemp);
                        pStr = ptemp;
                    }
                }
            }

            /*
             * Write out the translated string
             */
            Status = TermsrvPutString(
                         DestHandle,
                         pStr,
                         StringSize
                         );

              RtlFreeHeap( RtlProcessHeap(), 0, pStr );

            if( !NT_SUCCESS(Status) ) {
                DBGPRINT(("TermsrvIniCopyLoop: Error 0x%x doing NtWriteFile\n",Status));
                RtlFreeAnsiString( &AnsiUserDir );
                RtlFreeAnsiString( &AnsiSysDir );
                return( Status );
            }

        } // end while(1)
    }
    else
    {
        return STATUS_UNSUCCESSFUL;

    }
}


/*****************************************************************************
 *
 *  TermsrvGetString
 *
 *   This function gets a "string" from an ini file and returns it to the
 *   caller. Since processing must be done in memory on the strings, they
 *   are returned NULL terminated, but this NULL is NOT included in the
 *   returned string size. Of course, buffer size calculations take this
 *   NULL into account. Strings retain any <CR><LF> characters and are
 *   not stripped out like the C runtime.
 *
 *   The I/O buffer used is passed in by the caller. If the IoBufIndex is
 *   not 0, this is an indication that there is still data left in the buffer
 *   from a previous operation. This data is used before reading additional
 *   data from the file handle. This handles the case where string breaks
 *   do not occur at buffer boundries.
 *
 *   Strings are returned in newly allocated memory on the process heap.
 *   The caller is reponsible for freeing them when done.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

NTSTATUS
TermsrvGetString(
    HANDLE SrcHandle,
    PCHAR  *ppStringPtr,
    PULONG pStringSize,
    PCHAR  pIOBuf,
    ULONG  IOBufSize,
    PULONG pIOBufIndex,
    PULONG pIOBufFillSize
    )
{
    NTSTATUS Status;
    IO_STATUS_BLOCK   Iosb;
    BOOL  SawNL = FALSE;
    ULONG StrSize = 0;
    ULONG StrBufSize = 512;
    PCHAR pStr = NULL;

    /*
     * first process any left over data in the current I/O buffer
     */
    if( *pIOBufIndex < *pIOBufFillSize ) {

        Status = TermsrvProcessBuffer(
                     &pStr,
                     &StrSize,
                     &StrBufSize,
                     &SawNL,
                     pIOBuf,
                     pIOBufIndex,
                     pIOBufFillSize
                     );

        if( Status == STATUS_SUCCESS ) {
            *ppStringPtr = pStr;
            *pStringSize = StrSize;
            return( STATUS_SUCCESS );
        }
        else if (Status == STATUS_MORE_PROCESSING_REQUIRED) {
            /*
             * emptied the buffer
             */
            *pIOBufIndex = 0;
            *pIOBufFillSize = 0;

            // fall through to read more data
        }
        else {
            // Error
            if( pStr ) {
                RtlFreeHeap( RtlProcessHeap(), 0, pStr );
            }
            *ppStringPtr = NULL;
            *pStringSize = 0;
            return( Status );
        }
    }

    while( 1 ) {

        ASSERT( *pIOBufIndex == 0 );
        ASSERT( *pIOBufFillSize == 0 );

        Iosb.Status = STATUS_SUCCESS;
        Status = NtReadFile(
                     SrcHandle,
                     NULL,      // Event
                     NULL,      // APC routine
                     NULL,      // APC context
                     &Iosb,
                     pIOBuf,
                     IOBufSize,
                     NULL,      // ByteOffset (not used since in synchronous I/O)
                     NULL       // Key
                     );

        if( Status == STATUS_PENDING ) {
            Status = NtWaitForSingleObject( SrcHandle, FALSE, NULL );
        }

        if( NT_SUCCESS(Status) ) {
            // Get final I/O status
            Status = Iosb.Status;
        }

        if( !NT_SUCCESS(Status) ) {

        if( (Status == STATUS_END_OF_FILE) && (StrSize != 0) ) {

                // Force the string finished
                pStr[StrSize] = (CHAR)NULL;
                *pStringSize = StrSize;
                *ppStringPtr = pStr;
                return( STATUS_SUCCESS );
            }

            // Free the buffer
            if( pStr ) {
                RtlFreeHeap( RtlProcessHeap(), 0, pStr );
            }
            *ppStringPtr = NULL;
            *pStringSize = 0;
            if (Status != STATUS_END_OF_FILE)
                DBGPRINT(("TermsrvIniCopyLoop: Error 0x%x doing NtReadFile\n",Status));
            return( Status );
        }

        // Fill in the count
        *pIOBufFillSize = (ULONG)Iosb.Information;

        /*
         * Now process this buffer of data
         */
        Status = TermsrvProcessBuffer(
                     &pStr,
                     &StrSize,
                     &StrBufSize,
                     &SawNL,
                     pIOBuf,
                     pIOBufIndex,
                     pIOBufFillSize
                     );

        if( Status == STATUS_SUCCESS ) {
            *ppStringPtr = pStr;
            *pStringSize = StrSize;
            return( STATUS_SUCCESS );
        }
        else if (Status == STATUS_MORE_PROCESSING_REQUIRED) {
            /*
             * emptied the buffer
             */
            *pIOBufIndex = 0;
            *pIOBufFillSize = 0;

            // fall through to read more data
        }
        else {
            // Error
            if( pStr ) {
                RtlFreeHeap( RtlProcessHeap(), 0, pStr );
            }
            *ppStringPtr = NULL;
            *pStringSize = 0;
            return( Status );
        }
    } // end while(1)
}

/*****************************************************************************
 *
 *  TermsrvProcessBuffer
 *
 *   Process a buffer of data.
 *
 *   This uses state passed in by the caller since the string can be
 *   partially built, and the buffer may not be fully processed when
 *   a string completes.
 *
 *   Can return if it completes a string with data still in buffer.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

NTSTATUS
TermsrvProcessBuffer(
    PCHAR  *ppStr,
    PULONG pStrSize,
    PULONG pStrBufSize,
    PBOOL  pSawNL,
    PCHAR  pIOBuf,
    PULONG pIOBufIndex,
    PULONG pIOBufFillSize
    )
{
    PCHAR pStr;
    ULONG Index;
    BOOL  SawNL;

    /*
     * See if we are starting a new string
     */
    if( *ppStr == NULL ) {

        pStr = RtlAllocateHeap( RtlProcessHeap(), 0, *pStrBufSize );
        if( pStr == NULL ) {
            DBGPRINT(("TermsrvProcessBuf: Memory allocation failure\n"));
            return( STATUS_NO_MEMORY );
        }

        // Set it to our caller
        *ppStr = pStr;
    }

    /*
     * Get passed in state to local variables
     */
    pStr = *ppStr;
    Index = *pStrSize;
    SawNL = *pSawNL;

    while ( *pIOBufIndex < *pIOBufFillSize ) {

        pStr[Index] = pIOBuf[*pIOBufIndex];
        if( IS_NEWLINE_CHAR( pStr[Index] ) ) {

            /*
             * Mark the we saw an end of string character.
             * We will keep putting them into the buffer until a
             * non-NL character is encountered. This handles the
             * variations for <CR><LF>, <CR> alone, or <CR><LF><CR>
             * if its been mangled by a buggy editor.
             */
            SawNL = TRUE;
        }
        else {
            /*
             * If we saw a previous NL character, and this character
             * is not one, we do not take this one, but put a NULL in
             * its place and return. NOTE: Do not bump the count, since
             * the count does not include the NULL.
             */
            if( SawNL ) {
                pStr[Index] = (CHAR)NULL;
                *pStrSize = Index;
                return( STATUS_SUCCESS );
            }
        }

        Index++;
        (*pIOBufIndex)++;
        if( Index >= *pStrBufSize ) {

            // Grow the string buffer
            if( !TermsrvReallocateBuf( &pStr, pStrBufSize, (*pStrBufSize) * 2 ) ) {
                if( pStr ) {
                    RtlFreeHeap( RtlProcessHeap(), 0, pStr );
                }
                *ppStr = NULL;
                DBGPRINT(("TermsrvIniCopyLoop: Memory re-allocation failure\n"));
                return( STATUS_NO_MEMORY );
            }
            // Memory buffer has been re-allocated
            *ppStr = pStr;
            *pStrBufSize = (*pStrBufSize) * 2;
        }
    }

    *pStrSize = Index;
    *pSawNL = SawNL;

    /*
     * emptied the buffer without building a whole string
     */
    return( STATUS_MORE_PROCESSING_REQUIRED );
}

/*****************************************************************************
 *
 *  TermsrvReallocateBuf
 *
 *   Grow the buffer, copy data to new buffer.
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

BOOL
TermsrvReallocateBuf(
    PCHAR  *ppStr,
    PULONG pStrBufSize,
    ULONG  NewSize
    )
{
    PCHAR ptr;
    ULONG CopyCount;

    CopyCount = *pStrBufSize;

    ptr = RtlAllocateHeap( RtlProcessHeap(), 0, NewSize );
    if( ptr == NULL ) {
        return( FALSE );
    }

    RtlMoveMemory( ptr, *ppStr, CopyCount );

    RtlFreeHeap( RtlProcessHeap(), 0, *ppStr );

    *ppStr = ptr;

    return( TRUE );
}

/*****************************************************************************
 *
 *  TermsrvPutString
 *
 *   Write out the current string to the destination file handle
 *
 * ENTRY:
 *   Param1 (input/output)
 *     Comments
 *
 * EXIT:
 *   STATUS_SUCCESS - no error
 *
 ****************************************************************************/

NTSTATUS
TermsrvPutString(
    HANDLE DestHandle,
    PCHAR  pStr,
    ULONG  StringSize
    )
{
    NTSTATUS Status;
    IO_STATUS_BLOCK   Iosb;

    Iosb.Status = STATUS_SUCCESS;

    Status = NtWriteFile(
                 DestHandle,
                 NULL,      // Event
                 NULL,      // APC routine
                 NULL,      // APC context
                 &Iosb,
                 pStr,
                 StringSize,
                 NULL,      // ByteOffset (not used since in synchronous I/O)
                 NULL       // Key
                 );

    if( Status == STATUS_PENDING ) {
        Status = NtWaitForSingleObject( DestHandle, FALSE, NULL );
    }

    if( NT_SUCCESS(Status) ) {
        // Get final I/O status
        Status = Iosb.Status;
    }

    return( Status );
}


/*****************************************************************************
 *
 *  TermsrvCheckNewIniFiles
 *
 *  This routine will check the timestamps of the .ini files installed by the
 *  system administrator, and see if any of the user's .ini file are out of
 *  date, and if so, they will be renamed.
 *
 * ENTRY:
 *
 * EXIT:
 *   No return value.
 *
 ****************************************************************************/

void TermsrvCheckNewIniFiles(void)
{
    NTSTATUS Status;

    #if defined (_WIN64)
    Status = TermsrvCheckNewIniFilesInternal(REG_NTAPI_SOFTWARE_WOW6432_TSERVER);
    if (!NT_SUCCESS(Status)) {
        return;
    }
    #endif // defined(_WIN64)

    Status = TermsrvCheckNewIniFilesInternal(REG_NTAPI_SOFTWARE_TSERVER);
    if (!NT_SUCCESS(Status)) {
        return;
    }

    // Update the user's sync time in the registry
    TermsrvSetUserSyncTime();
}

/*****************************************************************************
 *
 *  TermsrvCheckNewIniFilesInternal
 *
 *  This routine will check the timestamps of the .ini files installed by the
 *  system administrator, and see if any of the user's .ini file are out of
 *  date, and if so, they will be renamed.
 *
 * ENTRY:
 *       LPCWSTR wszBaseKeyName
 *
 * EXIT:
 *   No return value.
 *
 ****************************************************************************/

NTSTATUS
TermsrvCheckNewIniFilesInternal(
        IN LPCWSTR wszBaseKeyName)
{
    PWCHAR pwch;
    UNICODE_STRING UniString, UniUserDir, UniNTDir = {0,0,NULL};
    OBJECT_ATTRIBUTES ObjectAttr;
    FILE_NETWORK_OPEN_INFORMATION BasicInfo;
    HANDLE hKey = NULL, hWinDir = NULL;
    NTSTATUS Status;
    ULONG ulcnt, ullen, ultmp;
    WCHAR wcWinDir[MAX_PATH], wcbuff[MAX_PATH];
    PKEY_VALUE_FULL_INFORMATION pKeyValInfo;
    PKEY_BASIC_INFORMATION pKeyInfo;
    IO_STATUS_BLOCK IOStatus;

    g_debugIniMap = IsDebugIniMapEnabled();

    // Allocate a buffer for the key value name and time info
    ullen = sizeof(KEY_VALUE_FULL_INFORMATION) + MAX_PATH*sizeof(WCHAR) +
            sizeof(ULONG);
    pKeyValInfo = RtlAllocateHeap(RtlProcessHeap(),
                                  0,
                                  ullen);

    // If we didn't get the buffer, return
    if (!pKeyValInfo) {
        return STATUS_NO_MEMORY;
    }

    // Open up the registry key to get the last sync time for this user
    wcscpy(wcbuff,wszBaseKeyName);
    wcscat(wcbuff,TERMSRV_INIFILE_TIMES_SHORT);

    RtlInitUnicodeString(&UniString,
                         wcbuff);
    InitializeObjectAttributes(&ObjectAttr,
                               &UniString,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);
    Status = NtOpenKey(&hKey, KEY_READ, &ObjectAttr);

    // If we successfully opened the key, check if there are any new entries
    if (NT_SUCCESS(Status)) {

        // Since we already allocated a hunk of memory, use the value buffer
        // for the key info query
        pKeyInfo = (PKEY_BASIC_INFORMATION)pKeyValInfo;

        // Get the last time anyone wrote to "IniFile Times" key
        Status = NtQueryKey(hKey,
                            KeyBasicInformation,
                            pKeyInfo,
                            ullen,
                            &ultmp);

        // We got the last write time OK, now get the last time we sync'd
        if (NT_SUCCESS(Status) && TermsrvGetUserSyncTime(&ultmp)) {

            // Convert the time value to seconds since 1970
            RtlTimeToSecondsSince1970 (&pKeyInfo->LastWriteTime,
                                       &ulcnt);

            // If no .ini files or reg entries have been updated since the last
            // time we sync'd this user, just return
            if (ultmp >= ulcnt) {
                NtClose(hKey);
                RtlFreeHeap(RtlProcessHeap(), 0, pKeyValInfo);
                return STATUS_SUCCESS;
            }
        }

        TermsrvCheckNewRegEntries(wszBaseKeyName);

        // Set up UniUserDir to point at wcbuff
        UniUserDir.Buffer = wcWinDir;
        UniUserDir.Length = 0;
        UniUserDir.MaximumLength = sizeof(wcbuff);

        Status = GetPerUserWindowsDirectory(&UniUserDir);

        if (NT_SUCCESS(Status)) {

            // Convert to an NT path
            if (RtlDosPathNameToNtPathName_U(UniUserDir.Buffer,
                                             &UniNTDir,
                                             NULL,
                                             NULL)) {
                InitializeObjectAttributes(&ObjectAttr,
                                           &UniNTDir,
                                           OBJ_CASE_INSENSITIVE,
                                           NULL,
                                           NULL);

                // Open the user's windows directory
                IOStatus.Status = STATUS_SUCCESS;
                Status = NtOpenFile(&hWinDir,
                                    FILE_GENERIC_READ,
                                    &ObjectAttr,
                                    &IOStatus,
                                    FILE_SHARE_READ|FILE_SHARE_WRITE,
                                    FILE_SYNCHRONOUS_IO_NONALERT);
            } else {
                Status = STATUS_NO_SUCH_FILE;
            }
        }

        // Go through each of the keys, checking if it's newer than the user's
        // version of the file, and if so rename it
        ulcnt = 0;
        wcscat(wcWinDir, L"\\");
        UniUserDir.Length += 2;         // add in length of \ seperator
        while (NT_SUCCESS(Status)) {
            Status = NtEnumerateValueKey(hKey,
                                         ulcnt++,
                                         KeyValueFullInformation,
                                         pKeyValInfo,
                                         ullen,
                                         &ultmp);
            if (NT_SUCCESS(Status)) {

                RtlMoveMemory(wcbuff, pKeyValInfo->Name, pKeyValInfo->NameLength);
                wcbuff[pKeyValInfo->NameLength/sizeof(WCHAR)] = L'\0';

                // Get rid of the .ini extension
                if (pwch = wcschr(wcbuff, L'.')) {
                    *pwch = L'\0';
                }

                // Get the compatibility flags for this .ini file
                GetTermsrCompatFlags(wcbuff,
                                     &ultmp,
                                     CompatibilityIniFile);

                // If we removed the extension, put it back
                if (pwch) {
                    *pwch = '.';
                }

                // If the INISYNC compat bit is set, don't rename the file
                if ((ultmp & (TERMSRV_COMPAT_INISYNC | TERMSRV_COMPAT_WIN16)) !=
                     (TERMSRV_COMPAT_INISYNC | TERMSRV_COMPAT_WIN16)) {

                    RtlInitUnicodeString(&UniString, wcbuff);

                    // Query the last write time of the .ini file
                    InitializeObjectAttributes(&ObjectAttr,
                                               &UniString,
                                               OBJ_CASE_INSENSITIVE,
                                               hWinDir,
                                               NULL);

                    // Get the last write time
                    if (NT_SUCCESS(NtQueryFullAttributesFile( &ObjectAttr,
                                                              &BasicInfo ))) {

                        // Convert the last write time to seconds
                        RtlTimeToSecondsSince1970(&BasicInfo.LastWriteTime,
                                                  &ultmp);

                        // Check if the system version is newer than the user's
                        // version
                        if (*(PULONG)((PCHAR)pKeyValInfo +
                                      pKeyValInfo->DataOffset) > ultmp) {

                            // Concatenate the .ini name onto the user's path
                            wcscpy(wcWinDir + (UniUserDir.Length/sizeof(WCHAR)),
                                   wcbuff);

                            // Create the target name to rename the file
                            // (inifile.ctx)
                            wcscpy(wcbuff, wcWinDir);
                            pwch = wcsrchr(wcbuff, L'.');
                            if (pwch) {
                                wcscpy(pwch, L".ctx");
                            } else {
                                wcscat(pwch, L".ctx");
                            }

                            // Rename the .ini file
                            MoveFileExW(wcWinDir,
                                        wcbuff,
                                        MOVEFILE_REPLACE_EXISTING);
                        }
                    }
                }
            }
        }

        // Close the handles, if they were opened
        if (hKey) {
            NtClose(hKey);
        }
        if (hWinDir) {
            NtClose(hWinDir);
        }

    }


    // Free the memory we allocated
    RtlFreeHeap( RtlProcessHeap(), 0, pKeyValInfo );
    if (UniNTDir.Buffer) {
        RtlFreeHeap(RtlProcessHeap(), 0, UniNTDir.Buffer);
    }

    return STATUS_SUCCESS;
}



/*****************************************************************************
 *
 *  TermsrvCheckKeys
 *
 *  This recursive routine will check for any subkeys under the system root
 *  key passed in.  It will delete the corresponding key in the user's
 *  software registry if the user's key is older than the system key.  If the
 *  INISYNC bit is set for this registry key or the key is still has subkeys,
 *  it won't be deleted.  If the key doesn't exist in the user's registry,
 *  it will be added.
 *
 * ENTRY:
 *  HANDLE hKeySysRoot: handle to key in system section of registry
 *  HANDLE hKeyUsrRoot: handle to key in user section of registry
 *  PKEY_BASIC_INFORMATION pKeySysInfo: Ptr to buffer for key basic info struc
 *  PKEY_FULL_INFORMATION pKeyUsrInfo: Ptr to buffer for full key info struc
 *  ULONG ulcsys: Size of SysInfo buffer
 *  ULONG ulcusr: Size of UsrInfo buffer
 *
 * EXIT:
 *   SUCCESS:
 *      STATUS_SUCCESS
 *   FAILURE:
 *      NTSTATUS Return Code
 *
 ****************************************************************************/
NTSTATUS TermsrvCheckKeys(HANDLE hKeySysRoot,
                      HANDLE hKeyUsrRoot,
                      PKEY_BASIC_INFORMATION pKeySysInfo,
                      PKEY_FULL_INFORMATION pKeyUsrInfo,
                      ULONG ulcsys,
                      ULONG ulcusr,
                      DWORD indentLevel )
{
    NTSTATUS Status = STATUS_SUCCESS, Status2;
    ULONG ultemp, ulcnt = 0;
    UNICODE_STRING UniPath, UniString;
    OBJECT_ATTRIBUTES ObjAttr;
    HANDLE hKeyUsr = NULL, hKeySys = NULL;
    LPWSTR wcbuff = NULL;
    ULONG aulbuf[4];
    PKEY_FULL_INFORMATION pKeyUsrFullInfoSaved = NULL ;
    ULONG   sizeFullInfo;
    PKEY_VALUE_PARTIAL_INFORMATION pValKeyInfo =
        (PKEY_VALUE_PARTIAL_INFORMATION)aulbuf;

    ++indentLevel;
    
    Status = GetFullKeyPath(hKeyUsrRoot,NULL,&wcbuff);
    if(!NT_SUCCESS(Status)) {
        return Status;
    }

    // Get the compatibility flags for this entry
    GetTermsrCompatFlags(wcbuff,
                         &ultemp,
                         CompatibilityRegEntry);

    LocalFree(wcbuff);

    // If the INISYNC or NOREGMAP bits are set for this entry,
    // return, since there's nothing to do
    if ((ultemp & TERMSRV_COMPAT_WIN32) &&
         (ultemp & (TERMSRV_COMPAT_NOREGMAP | TERMSRV_COMPAT_INISYNC))) {
        return(STATUS_NO_MORE_ENTRIES);
    }

    // Save the current info for the current user key
    // @@@
    if (!hKeyUsrRoot)
    {
        DBGPRINT(("ERROR : LINE : %4d, why is this null? \n", __LINE__ ));
        return(STATUS_NO_MORE_ENTRIES );
    }

    // use a zero length query to get the actual length
    Status = NtQueryKey(hKeyUsrRoot,
                   KeyFullInformation,
                   pKeyUsrFullInfoSaved,
                   0,
                   &ultemp) ;

	if ( !NT_SUCCESS( Status ) )
	{
		if (Status == STATUS_BUFFER_TOO_SMALL )
		{
			sizeFullInfo = ultemp;
		
			pKeyUsrFullInfoSaved = RtlAllocateHeap(RtlProcessHeap(), 0, sizeFullInfo );

			if ( ! pKeyUsrFullInfoSaved )
			{
				return STATUS_NO_MEMORY;
			}

			Status = NtQueryKey(hKeyUsrRoot,
					   KeyFullInformation,
					   pKeyUsrFullInfoSaved,
					   sizeFullInfo,
					   &ultemp);
			
			if( !NT_SUCCESS(Status ) )
			{
				DBGPRINT(("ERROR : LINE : %4d, Status =0x%lx , ultemp=%d\n", __LINE__ , Status, ultemp));
				RtlFreeHeap( RtlProcessHeap(), 0, pKeyUsrFullInfoSaved);
				return( Status );
			}		

		}
		else
		{

            DBGPRINT(("ERROR : LINE : %4d, Status =0x%lx \n", __LINE__ , Status ));
			return Status;
		}
	}

    // Go through each of the subkeys, checking for user keys that are older
    // than the system version of the keys
    while (NT_SUCCESS(Status)) {

        Status = NtEnumerateKey(hKeySysRoot,
                                ulcnt++,
                                KeyBasicInformation,
                                pKeySysInfo,
                                ulcsys,
                                &ultemp);

        // See if there are any user keys under this key that are out of date
        if (NT_SUCCESS(Status)) {

            // Null terminate the key name
            pKeySysInfo->Name[pKeySysInfo->NameLength/sizeof(WCHAR)] = L'\0';

            // Create a unicode string for the key name
            RtlInitUnicodeString(&UniPath, pKeySysInfo->Name);

            InitializeObjectAttributes(&ObjAttr,
                                       &UniPath,
                                       OBJ_CASE_INSENSITIVE,
                                       hKeySysRoot,
                                       NULL);

            Debug1( indentLevel, __LINE__, L"system", &UniPath );

            // Open up the system key
            Status2 = NtOpenKey(&hKeySys,
                                KEY_READ,
                                &ObjAttr);

            // We opened up the system key, now open the user key
            if (NT_SUCCESS(Status2)) {

                // Setup the object attr struc for the user key
                InitializeObjectAttributes(&ObjAttr,
                                           &UniPath,
                                           OBJ_CASE_INSENSITIVE,
                                           hKeyUsrRoot,
                                           NULL);

                // Open up the user key
                Status2 = NtOpenKey(&hKeyUsr,
                                    MAXIMUM_ALLOWED,
                                    &ObjAttr);

                // Check if there are any subkeys under this key
                if (NT_SUCCESS(Status2)) {

                    Debug1(indentLevel, __LINE__, L"user", &UniPath );

                    TermsrvCheckKeys(hKeySys,
                                 hKeyUsr,
                                 pKeySysInfo,
                                 pKeyUsrInfo,
                                 ulcsys,
                                 ulcusr,
                                 indentLevel);

                    NtClose(hKeyUsr);
                }

                // key doesn't exist, clone system key to user
                else {
                    
                    Status2 = GetFullKeyPath(hKeyUsrRoot,pKeySysInfo->Name,&wcbuff);
                    
                    if(NT_SUCCESS(Status2)) {

                        // don't clone if mapping off for this registry entry
                        GetTermsrCompatFlags(wcbuff,
                                             &ultemp,
                                             CompatibilityRegEntry);
                        
                        LocalFree(wcbuff);

                        if (((ultemp & (TERMSRV_COMPAT_WIN32 | TERMSRV_COMPAT_NOREGMAP)) !=
                             (TERMSRV_COMPAT_WIN32 | TERMSRV_COMPAT_NOREGMAP) ))
                        {
                            Status2 = NtQueryKey(hKeySys,
                                                 KeyFullInformation,
                                                 pKeyUsrInfo,
                                                 ulcusr,
                                                 &ultemp);

                            if (NT_SUCCESS(Status2)) {

                                // don't clone if key previously deleted
                                RtlInitUnicodeString(&UniString, TERMSRV_COPYONCEFLAG);
                                Status2 = NtQueryValueKey(hKeySys,
                                                          &UniString,
                                                          KeyValuePartialInformation,
                                                          pValKeyInfo,
                                                          sizeof(aulbuf),
                                                          &ultemp);

                                if (!(NT_SUCCESS(Status2) && (pValKeyInfo->Data))) {
                                    // Setup the unicode string for the class
                                    InitUnicodeStringWithLen(&UniString,
                                                             pKeyUsrInfo->ClassLength ? pKeyUsrInfo->Class : NULL,
                                                             (USHORT)pKeyUsrInfo->ClassLength);

                                    Debug1(indentLevel, __LINE__, L"creating user key", ObjAttr.ObjectName  );

                                    Status2 = NtCreateKey(&hKeyUsr,
                                                          MAXIMUM_ALLOWED,
                                                          &ObjAttr,
                                                          0,
                                                          &UniString,
                                                          REG_OPTION_NON_VOLATILE,
                                                          &ultemp);

                                    if (NT_SUCCESS(Status2)) {

                                        Debug1(indentLevel, __LINE__, L"cloning key", ObjAttr.ObjectName  );

                                        TermsrvCloneKey(hKeySys,
                                                    hKeyUsr,
                                                    pKeyUsrInfo,
                                                    TRUE);
                                    }
                                }
                            }
                        }
                    }
                }
                NtClose(hKeySys);
            }
        }
    }

    // Get the info for the user key
    if (NtQueryKey(hKeyUsrRoot,
                   KeyFullInformation,
                   pKeyUsrInfo,
                   ulcusr,
                   &ultemp) == STATUS_SUCCESS) {

        // Now get the info for the system key (again)
        if (NtQueryKey(hKeySysRoot,
                       KeyBasicInformation,
                       pKeySysInfo,
                       ulcsys,
                       &ultemp) == STATUS_SUCCESS) {

            // Get the compatibility flags for this registry entry
            pKeySysInfo->Name[pKeySysInfo->NameLength/sizeof(WCHAR)] = L'\0';
            GetTermsrCompatFlags(pKeySysInfo->Name,
                                 &ultemp,
                                 CompatibilityRegEntry);

            
            //check if it's older than the system version
            if( pKeyUsrFullInfoSaved->LastWriteTime.QuadPart <
                 pKeySysInfo->LastWriteTime.QuadPart) 
            {
                DebugTime(indentLevel, __LINE__, L"User key time", pKeyUsrFullInfoSaved->LastWriteTime );
                DebugTime(indentLevel, __LINE__, L"Sys  key time", pKeySysInfo->LastWriteTime);

                Debug2( indentLevel, __LINE__, L"Key Old, values being cloned",  pKeySysInfo->Name, pKeySysInfo->NameLength );

                if(NtQueryKey(hKeySysRoot,
                             KeyFullInformation,
                             pKeyUsrInfo,
                             ulcusr,
                             &ultemp) == STATUS_SUCCESS) {

                    TermsrvCloneKey(hKeySysRoot,
                                    hKeyUsrRoot,
                                    pKeyUsrInfo,//actually it is system key information
                                    FALSE);
                }
            }
        }
    }

    RtlFreeHeap( RtlProcessHeap(), 0, pKeyUsrFullInfoSaved);
    return(Status);
}




/*****************************************************************************
 *
 *  TermsrvCheckNewRegEntries
 *
 *  This routine will check the user's registry keys, and see if any of them
 *  are older than the system versions.  If so, the old key will be removed.
 *
 * ENTRY:
 *        IN LPCWSTR wszBaseKeyName
 *
 * EXIT:
 *   No return value.
 *
 ****************************************************************************/

void 
TermsrvCheckNewRegEntries(
        IN LPCWSTR wszBaseKeyName)
{
    NTSTATUS Status;
    ULONG ulcsys, ulcusr;
    UNICODE_STRING UniPath;
    OBJECT_ATTRIBUTES ObjAttr;
    PKEY_BASIC_INFORMATION pKeySysInfo = NULL;
    PKEY_FULL_INFORMATION pKeyUserInfo = NULL;
    HANDLE hKeyUser, hKeySys = NULL;
    WCHAR wcuser[MAX_PATH], wcsys[MAX_PATH];

    DWORD   indentLevel = 0;

    // Oct 15, 1999
    // This is BAD ! The Status bit was not initiazted to zero, which causes intermitent
    // execution by this function. The problem is that even if the status bit is init'd
    // to zero, then we can get the wrong behavior which will cause Office97 installation to
    // go wrong.
    // See BUG ID 412419
    // Here is what woudl happen: Install any app ( say TsClient). This would cause
    // an update to a Key in HKDU called Explorer\ShellFolders, just a refresh (no real change).
    // Then, if Admin did an logout and login, the call from UserInit.EXE into this
    // function (assuming by chance Status=0 was on the stack) would cause deletion of
    // that key (ShellFolder). But once Explorer starts, it writes to the ShellFolder with
    // a subset of original 19 values.
    // The problem is that if then, you decide to install Office97, setup.exe would look
    // in the same key for a value called "template" which is now missing. Explorer
    // would then create it, but it would point to some other than default location.
    // When all was done, our office97 compat script would be looking to where the
    // "template" value used to point (the default location), not where it is pointing now.
    //
    // we decide to disable this func by calling return right here, and instead, rely
    // on the TS mechanism to fault in keys.

    // Oct 31, 1999
    // I have decided to initialize the status var and let this func run, in addition to
    // marking the Explorer\ShellFolders as a do-not propagate key tree.
    //
    // It was discovered that after installing Office2000, when a user clicks on the
    // start-menu-> Open Office Docs link, MSI starts to run since user's hive is missing some
    // keys.
    //
    // The reason MSI does not see the keys in HKCU is because MSI has the TS-aware bit set,
    // which means that there are no faulting-in for any keys. The same is true for the Explorer.
    // On the other hand, when an app such as Office runs, since it is not ts-aware, we
    // fault in the keys that office touches. I verified this to work as expected.
    // The problem is that when you click on "Open Office Documents", you do so from the
    // explorer and when Explorer opens keys in the registry, since explorer is TS-aware,
    // those keys are not faulted in. I have verified that if you mark explorer as a non-TS-aware
    // app, the problem goes away.
    // We made a recent change in TS code (B-bug 412419, bld 2156+) to fix a different
    // problem which has now uncovered the reliance of the Explorer to get keys
    // faulted in during login.
    //      Specifically, TS used to fault in all keys at login time,
    //      regardless of the need. Post 2156, TS faults in only keys upon
    //      access by non-ts-aware apps. This was to fix a bug based on
    //      what we considered to be our most informed and well tested opinion. That
    //      has turned out to be wrong.
    // It is too risky to mark explorer non-ts-aware this late, so we must change the fix for 412419.
    // This should also make Bruno Amice very happy, since the fix will be as it was
    // advocated by him.
    Status = STATUS_SUCCESS;


    // Get a buffer for the system key info
    ulcsys = sizeof(KEY_BASIC_INFORMATION) + MAX_PATH*sizeof(WCHAR);
    pKeySysInfo = RtlAllocateHeap(RtlProcessHeap(),
                                   0,
                                   ulcsys);
    if (!pKeySysInfo) {
        Status = STATUS_NO_MEMORY;
    }

    // Get a buffer for the user key info
    if (NT_SUCCESS(Status)) {

        ulcusr = sizeof(KEY_FULL_INFORMATION) + MAX_PATH*sizeof(WCHAR);
        pKeyUserInfo = RtlAllocateHeap(RtlProcessHeap(),
                                       0,
                                       ulcusr);
        if (!pKeyUserInfo) {
            Status = STATUS_NO_MEMORY;
        }
    }

    // We have the necessary buffers, start checking the keys
    if (NT_SUCCESS(Status)) {

        // Build a string that points to Citrix\Install\Software
        wcscpy(wcsys, wszBaseKeyName);
        wcscat(wcsys, TERMSRV_INSTALL_SOFTWARE_SHORT);


        // Build up a string for this user's software section
        Status = RtlFormatCurrentUserKeyPath( &UniPath );
        if (NT_SUCCESS(Status)) {
            wcscpy(wcuser, UniPath.Buffer);
            wcscat(wcuser, L"\\Software");

            // Free the original user path
            RtlFreeHeap( RtlProcessHeap(), 0, UniPath.Buffer );
        }

        if (NT_SUCCESS(Status)) {
            // Create a unicode string for the system key path
            RtlInitUnicodeString(&UniPath, wcsys);

            InitializeObjectAttributes(&ObjAttr,
                                       &UniPath,
                                       OBJ_CASE_INSENSITIVE,
                                       NULL,
                                       NULL);

            Debug1(indentLevel, __LINE__, L"system", &UniPath );

            Status = NtOpenKey(&hKeySys,
                               KEY_READ,
                               &ObjAttr);
        }

        if (NT_SUCCESS(Status)) {
            // Create a unicode string for the user key path
            RtlInitUnicodeString(&UniPath, wcuser);

            InitializeObjectAttributes(&ObjAttr,
                                       &UniPath,
                                       OBJ_CASE_INSENSITIVE,
                                       NULL,
                                       NULL);

            Debug1(indentLevel, __LINE__, L"user", &UniPath );

            Status = NtOpenKey(&hKeyUser,
                               KEY_READ | DELETE,
                               &ObjAttr);
        }

        // Go through each of the keys, checking if the system version is
        // newer than the user version
        if (NT_SUCCESS(Status)) {
            TermsrvCheckKeys(hKeySys,
                         hKeyUser,
                         pKeySysInfo,
                         pKeyUserInfo,
                         ulcsys,
                         ulcusr,
                         indentLevel );

            // Close the user key
            NtClose(hKeyUser);
        }

        // If we allocated the system key, close it
        if (hKeySys) {
            NtClose(hKeySys);
        }
    }

    // Free up any memory we allocated
    if (pKeySysInfo) {
        RtlFreeHeap( RtlProcessHeap(), 0, pKeySysInfo);
    }
    if (pKeyUserInfo) {
        RtlFreeHeap( RtlProcessHeap(), 0, pKeyUserInfo);
    }

}


/*****************************************************************************
 *
 *  Ctxstristr
 *
 *  This is a case insensitive version of strstr.
 *
 * ENTRY:
 *   PCHAR pstring1 (In) - String to search in
 *   PCHAR pstring2 (In) - String to search for
 *
 * EXIT:
 *   TRUE  - User ini file should be sync'd
 *   FALSE - User ini file should be sync'd
 *
 ****************************************************************************/

PCHAR
Ctxstristr(
    PCHAR pstring1,
    PCHAR pstring2)
{
    PCHAR pch, ps1, ps2;

    pch = pstring1;

    while (*pch)
    {
        ps1 = pch;
        ps2 = pstring2;

        while (*ps1 && *ps2 && !(toupper(*ps1) - toupper(*ps2))) {
                   ps1++;
            ps2++;
        }

        if (!*ps2) {
            return(pch);
        }

        pch++;
    }
    return(NULL);
}

/*****************************************************************************
 *
 *  TermsrvLogInstallIniFile
 *
 *  This routine will write the time the .ini file was last updated into the
 *  Terminal Server\install section of the registry.
 *
 * ENTRY:
 *
 * EXIT:
 *   TRUE  - Success
 *   FALSE - Failure
 *
 ****************************************************************************/

BOOL TermsrvLogInstallIniFile(PUNICODE_STRING NtFileName)
{
    PWCHAR pwch;
    UNICODE_STRING UniString;
    OBJECT_ATTRIBUTES ObjectAttr;
    FILE_NETWORK_OPEN_INFORMATION BasicInfo;
    HANDLE hKey;
    NTSTATUS Status;
    ULONG ultmp;

    if (!TermsrvPerUserWinDirMapping()) {
        return FALSE;
    }

    // Open up the registry key to store the last write time of the file
    RtlInitUnicodeString(&UniString,
                         TERMSRV_INSTALL);

    InitializeObjectAttributes(&ObjectAttr,
                               &UniString,
                               OBJ_CASE_INSENSITIVE,
                               NULL,
                               NULL);

    // Open or create the Terminal Server\Install path
    Status = NtCreateKey(&hKey,
                         KEY_WRITE,
                         &ObjectAttr,
                         0,
                         NULL,
                         REG_OPTION_NON_VOLATILE,
                         &ultmp);

    // Now open or create the IniFile Times key
    if (NT_SUCCESS(Status)) {
        NtClose(hKey);

        RtlInitUnicodeString(&UniString,
                             TERMSRV_INIFILE_TIMES);

        InitializeObjectAttributes(&ObjectAttr,
                                   &UniString,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
        Status = NtCreateKey(&hKey,
                             KEY_WRITE,
                             &ObjectAttr,
                             0,
                             NULL,
                             REG_OPTION_NON_VOLATILE,
                             &ultmp);
    }

    // Opened up the registry key, now get the last write time of the file
    if (NT_SUCCESS(Status)) {

        // Query the last write time of the .ini file
        InitializeObjectAttributes(&ObjectAttr,
                                   NtFileName,
                                   OBJ_CASE_INSENSITIVE,
                                   NULL,
                                   NULL);
        Status = NtQueryFullAttributesFile( &ObjectAttr, &BasicInfo );

        // Got the last write time, convert to seconds and write it out
        if (NT_SUCCESS(Status)) {

            // Just save the .ini filename, get rid of the path
            pwch = wcsrchr(NtFileName->Buffer, L'\\') + 1;
            if (!pwch) {
                pwch = NtFileName->Buffer;
            }

            // Convert to seconds (so it fits in a DWORD)
            RtlTimeToSecondsSince1970 (&BasicInfo.LastWriteTime,
                                       &ultmp);

            RtlInitUnicodeString(&UniString,
                                 pwch);

            // Write it out the .ini file name and the last write time
            Status = NtSetValueKey(hKey,
                                   &UniString,
                                   0,
                                   REG_DWORD,
                                   &ultmp,
                                   sizeof(ultmp));
        }
        // Close the registry key
        NtClose(hKey);
    }

    return(NT_SUCCESS(Status));
}
/**********************************************************************
*
*  BOOL TermsrvLogInstallIniFileEx( WCHAR *pDosFileName )
*
*  This wraps TermsrvLogInstallIniFile() for dos name files instead of
*  NT-file-objects
*
*  The file name must have the full path since func will try to get
*  access time for that file.
*
*  EXIT:
*    TRUE  - Success
*    FALSE - Failure
**********************************************************************/

BOOL TermsrvLogInstallIniFileEx( WCHAR *pDosFileName )
{
    UNICODE_STRING uniString;

    BOOL rc= FALSE;

    if ( RtlDosPathNameToNtPathName_U( pDosFileName, &uniString, 0, 0 ) )
    {
        if ( rc = TermsrvLogInstallIniFile( & uniString ) )
        {
            RtlFreeHeap( RtlProcessHeap(), 0, uniString.Buffer );
        }
    }

    return rc;
}

/**********************************************************************
*
*  GetFullKeyPath()
*  
*  PURPOSE: 
*              Creates full key path given the key handle and subkey name.
*  
*  PARAMETERS: 
*              IN HANDLE hKeyParent - key handle 
*              IN LPCWSTR wszKey    - subkey name (may be NULL)
*              OUT LPWSTR *pwszKeyPath - on return contains a full key path
*              (caller must freee allocated memory with LocalFree()).
*
*  EXIT: NTSTATUS
*    
**********************************************************************/
NTSTATUS 
GetFullKeyPath(
        IN HANDLE hKeyParent,
        IN LPCWSTR wszKey,
        OUT LPWSTR *pwszKeyPath)
{
    NTSTATUS Status = STATUS_NO_MEMORY;
    PKEY_NAME_INFORMATION pNameInfo;
    ULONG cbSize = 0;
    
    *pwszKeyPath = NULL;

    cbSize = sizeof(KEY_NAME_INFORMATION) + MAX_PATH*sizeof(WCHAR);

    pNameInfo = (PKEY_NAME_INFORMATION) LocalAlloc(LPTR, cbSize);

    if(pNameInfo)
    {
        Status = NtQueryKey(
                        hKeyParent,
                        KeyNameInformation,
                        pNameInfo,
                        cbSize,
                        &cbSize);

        if(Status == STATUS_BUFFER_OVERFLOW)
        {
            LocalFree(pNameInfo);
            pNameInfo = (PKEY_NAME_INFORMATION) LocalAlloc(LPTR, cbSize);
            
            if(pNameInfo)
            {
                Status = NtQueryKey(
                            hKeyParent,
                            KeyNameInformation,
                            pNameInfo,
                            cbSize,
                            &cbSize);
            }
            else
            {
                return STATUS_NO_MEMORY;
            }
        }

        if(NT_SUCCESS(Status))
        {
            cbSize = pNameInfo->NameLength + sizeof(WCHAR);
            if(wszKey)
            {
                cbSize += wcslen(wszKey)*sizeof(WCHAR) + sizeof(L'\\');
            }
            
            *pwszKeyPath = (LPWSTR) LocalAlloc(LPTR, cbSize);

            if(*pwszKeyPath)
            {
                memcpy(*pwszKeyPath,pNameInfo->Name,pNameInfo->NameLength);
                (*pwszKeyPath)[pNameInfo->NameLength/sizeof(WCHAR)] = 0;
                
                if(wszKey)
                {
                    wcscat(*pwszKeyPath,L"\\");
                    wcscat(*pwszKeyPath,wszKey);
                }
            }
            else
            {
                Status = STATUS_NO_MEMORY;
            }
        }

        LocalFree(pNameInfo);
    }

    return Status;
}

VOID
InitUnicodeStringWithLen(
    OUT PUNICODE_STRING DestinationString,
    IN PCWSTR SourceString,
    IN USHORT StringLength
    )
{
    DestinationString->Buffer = (PWSTR)SourceString;
    DestinationString->Length = StringLength;
    if ( StringLength ) {
        DestinationString->MaximumLength = StringLength + (USHORT)sizeof(UNICODE_NULL);
    } 
    else {
        DestinationString->MaximumLength = 0;
    }
}