开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 查看源码
termutil.c
资源名称：win2ksrc.rar　[点击查看]
上传用户：caisha3
上传日期：2013-09-21
资源大小：208739k
文件大小：39k
源码类别：

Windows编程

开发平台：

Visual C++

termutil.c：源码内容
  1. /*++
  3. Copyright (c) 1998  Microsoft Corporation
  5. Module Name:
  7.     termutil.c
  9. Abstract:
  11.     Terminal server support functions and inifile syncing/merging code
  13. Author:
  16. Revision History:
  18. --*/
  20. #include "basedll.h"
  21. #include "hydraregapi.h"
  23. #define TERMSRV_INIFILE_TIMES L"\Registry\Machine\Software\Microsoft\Windows NT\CurrentVersion\Terminal Server\Install\IniFile Times"
  26. BOOL IsTerminalServerCompatible(VOID)
  27. {
  29. PIMAGE_NT_HEADERS NtHeader = RtlImageNtHeader( NtCurrentPeb()->ImageBaseAddress );
  31.     if (NtHeader->OptionalHeader.DllCharacteristics & IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE) {
  32.         return TRUE;
  33.     } else {
  34.         return FALSE;
  35.     }
  36. }
  38. BOOL IsTSAppCompatEnabled(VOID)
  39. {
  41.    NTSTATUS NtStatus;
  42.    OBJECT_ATTRIBUTES ObjectAttributes;
  43.    UNICODE_STRING UniString;
  44.    HKEY   hKey = 0;
  45.    ULONG  ul, ulcbuf;
  46.    PKEY_VALUE_PARTIAL_INFORMATION pKeyValInfo = NULL;
  48.    BOOL retval = TRUE;
  51.    RtlInitUnicodeString(&UniString,REG_NTAPI_CONTROL_TSERVER);
  55.    // Determine the value info buffer size
  56.    ulcbuf = sizeof(KEY_VALUE_FULL_INFORMATION) + MAX_PATH*sizeof(WCHAR) + 
  57.             sizeof(ULONG);
  59.    pKeyValInfo = RtlAllocateHeap(RtlProcessHeap(), 
  60.                                  0, 
  61.                                  ulcbuf);
  63.    // Did everything initialize OK?
  64.    if (UniString.Buffer && pKeyValInfo) {
  66.        InitializeObjectAttributes(&ObjectAttributes,
  67.                                   &UniString,
  68.                                   OBJ_CASE_INSENSITIVE,
  69.                                   NULL,
  70.                                   NULL
  71.                                  );
  72.    
  73.        NtStatus = NtOpenKey(&hKey, KEY_READ, &ObjectAttributes);
  74.    
  75.        if (NT_SUCCESS(NtStatus)) {
  76.    
  77.            RtlInitUnicodeString(&UniString, 
  78.                                L"TSAppCompat");
  79.            NtStatus = NtQueryValueKey(hKey,
  80.                                       &UniString,
  81.                                       KeyValuePartialInformation,
  82.                                       pKeyValInfo,
  83.                                       ulcbuf,
  84.                                       &ul);
  86.            if (NT_SUCCESS(NtStatus) && (REG_DWORD == pKeyValInfo->Type)) {
  88.                if ((*(PULONG)pKeyValInfo->Data) == 0) {
  89.                   retval = FALSE;
  90.                }
  92.            }
  94.            NtClose(hKey);
  95.        }
  96.    }
  98.    // Free up the buffers we allocated
  99.    // Need to zero out the buffers, because some apps (MS Internet Assistant)
  100.    // won't install if the heap is not zero filled.
  101.    if (pKeyValInfo) {
  102.        memset(pKeyValInfo, 0, ulcbuf);
  103.        RtlFreeHeap( RtlProcessHeap(), 0, pKeyValInfo );
  104.    }
  106.    return(retval);
  108. }
  110. BOOL IsSystemLUID(VOID)
  111. {
  112.     HANDLE      TokenHandle;
  113.     UCHAR       TokenInformation[ sizeof( TOKEN_STATISTICS ) ];
  114.     ULONG       ReturnLength;
  115.     LUID        CurrentLUID = { 0, 0 };
  116.     LUID        SystemLUID = SYSTEM_LUID;
  117.     NTSTATUS Status;
  119.     if ( CurrentLUID.LowPart == 0 && CurrentLUID.HighPart == 0 ) {
  121.         Status = NtOpenProcessToken( NtCurrentProcess(),
  122.                                      TOKEN_QUERY,
  123.                                      &TokenHandle );
  124.         if ( !NT_SUCCESS( Status ) )
  125.             return(TRUE);
  127.         NtQueryInformationToken( TokenHandle, TokenStatistics, &TokenInformation,
  128.                                  sizeof(TokenInformation), &ReturnLength );
  129.         NtClose( TokenHandle );
  131.         RtlCopyLuid(&CurrentLUID,
  132.                     &(((PTOKEN_STATISTICS)TokenInformation)->AuthenticationId));
  133.     }
  135.     if (RtlEqualLuid(&CurrentLUID, &SystemLUID)) {
  136.         return(TRUE);
  137.     } else {
  138.         return(FALSE );
  139.     }
  140. }
  143. void InitializeTermsrvFpns(void)
  144. {
  146.     HANDLE          dllHandle;
  148.     if (IsTerminalServerCompatible() ||
  149.        (IsSystemLUID()) ||
  150.        (!IsTSAppCompatEnabled())) {
  151.         return;
  152.     }
  154.     //
  155.     // Load Terminal Server application compatibility dll
  156.     //
  157.     dllHandle = LoadLibrary("tsappcmp.dll");
  159.     if (dllHandle) {
  161.         gpTermsrvFormatObjectName =
  162.             (PTERMSRVFORMATOBJECTNAME)GetProcAddress(dllHandle,"TermsrvFormatObjectName");
  164.         gpTermsrvGetComputerName =
  165.             (PTERMSRVGETCOMPUTERNAME)GetProcAddress(dllHandle,"TermsrvGetComputerName");
  167.         gpTermsrvAdjustPhyMemLimits =
  168.                 (PTERMSRVADJUSTPHYMEMLIMITS)GetProcAddress(dllHandle,"TermsrvAdjustPhyMemLimits");
  170.         gpTermsrvGetWindowsDirectoryA =
  171.                 (PTERMSRVGETWINDOWSDIRECTORYA)GetProcAddress(dllHandle,"TermsrvGetWindowsDirectoryA");
  173.         gpTermsrvGetWindowsDirectoryW =
  174.                 (PTERMSRVGETWINDOWSDIRECTORYW)GetProcAddress(dllHandle,"TermsrvGetWindowsDirectoryW");
  176.         gpTermsrvConvertSysRootToUserDir =
  177.                 (PTERMSRVCONVERTSYSROOTTOUSERDIR)GetProcAddress(dllHandle,"TermsrvConvertSysRootToUserDir");
  179.         gpTermsrvBuildIniFileName =
  180.                 (PTERMSRVBUILDINIFILENAME)GetProcAddress(dllHandle,"TermsrvBuildIniFileName");
  182.         gpTermsrvCORIniFile =
  183.                 (PTERMSRVCORINIFILE)GetProcAddress(dllHandle,"TermsrvCORIniFile");
  185.         gpGetTermsrCompatFlags =
  186.                 (PGETTERMSRCOMPATFLAGS)GetProcAddress(dllHandle,"GetTermsrCompatFlags");
  188.         gpTermsrvBuildSysIniPath =
  189.                 (PTERMSRVBUILDSYSINIPATH)GetProcAddress(dllHandle,"TermsrvBuildSysIniPath");
  191.         gpTermsrvCopyIniFile =
  192.         (PTERMSRVCOPYINIFILE)GetProcAddress(dllHandle,"TermsrvCopyIniFile");
  194.         gpTermsrvGetString =
  195.         (PTERMSRVGETSTRING)GetProcAddress(dllHandle,"TermsrvGetString");
  197.         gpTermsrvLogInstallIniFile =
  198.         (PTERMSRVLOGINSTALLINIFILE)GetProcAddress(dllHandle,"TermsrvLogInstallIniFile");
  201.     }
  202. }
  205. /*****************************************************************************
  206.  *
  207.  *  TermsrvAppInstallMode
  208.  *
  209.  *   Returns whether the system is in Install mode or not
  210.  *
  211.  * ENTRY:
  212.  *   Param1 (input/output)
  213.  *     Comments
  214.  *
  215.  * EXIT:
  216.  *   STATUS_SUCCESS - no error
  217.  *
  218.  ****************************************************************************/
  220. WINBASEAPI
  221. BOOL
  222. WINAPI
  223. TermsrvAppInstallMode( VOID )
  224. {
  226.     if ( BaseStaticServerData->fTermsrvAppInstallMode )
  227.         return( TRUE );
  229.     return( FALSE );
  230. }
  233. /*****************************************************************************
  234.  *
  235.  *  SetTermsrvAppInstallMode
  236.  *
  237.  *   Turns App install mode on or off. Default is off
  238.  *
  239.  * ENTRY:
  240.  *   Param1 (input/output)
  241.  *     Comments
  242.  *
  243.  * EXIT:
  244.  *   STATUS_SUCCESS - no error
  245.  *
  246.  ****************************************************************************/
  248. WINBASEAPI
  249. BOOL
  250. WINAPI
  251. SetTermsrvAppInstallMode( BOOL bState )
  252. {
  253.     NTSTATUS Status;
  255. #if defined(BUILD_WOW6432)
  256.     Status = CsrBasepSetTermsrvAppInstallMode(bState);
  257. #else
  258.     BASE_API_MSG m;
  259.     PBASE_SET_TERMSRVAPPINSTALLMODE c= (PBASE_SET_TERMSRVAPPINSTALLMODE)&m.u.SetTermsrvAppInstallMode;
  261.     c->bState = bState;
  262.     Status = CsrClientCallServer((PCSR_API_MSG)&m, NULL,
  263.                                  CSR_MAKE_API_NUMBER(BASESRV_SERVERDLL_INDEX,
  264.                                                      BasepSetTermsrvAppInstallMode),
  265.                                  sizeof( *c ));
  266. #endif
  268.     if ( !NT_SUCCESS( Status ) ) {
  269.         SetLastError( RtlNtStatusToDosError( Status ) );
  270.         return( FALSE );
  271.     }
  274.     if (IsTerminalServer() && IsTSAppCompatEnabled()) {
  275.         //
  276.         // Load tsappcmp.dll
  277.         //
  278.         if (gpTermsrvUpdateAllUserMenu == NULL) {
  279.             HANDLE          dllHandle;
  280.     
  281.             //
  282.             // Load Terminal Server application compatibility dll
  283.             //
  284.             dllHandle = LoadLibrary("tsappcmp.dll");
  285.     
  286.             if (dllHandle) {
  287.                 gpTermsrvUpdateAllUserMenu =
  288.                         (PTERMSRVUPDATEALLUSERMENU)GetProcAddress(dllHandle,"TermsrvUpdateAllUserMenu");
  289.             }
  290.         }
  291.     
  292.         if (gpTermsrvUpdateAllUserMenu) {
  293.             gpTermsrvUpdateAllUserMenu( bState == TRUE ? 0 : 1 );
  294.         }
  295.     }
  297.     return( TRUE );
  298. }
  301. /////////////////////////////////////////////////////////////////////////////
  302. /////////////////////////////////////////////////////////////////////////////
  303. /*
  304.   Ini File syncing/merging code
  306. */
  307. //////////////////////////////////////////////////////////////////////////////
  308. /* External Functions */
  309. NTSTATUS
  310. BaseDllOpenIniFileOnDisk(
  311.     PINIFILE_PARAMETERS a
  312.     );
  314. NTSTATUS
  315. BaseDllWriteKeywordValue(
  316.     IN PINIFILE_PARAMETERS a,
  317.     IN PUNICODE_STRING VariableName OPTIONAL
  318.     );
  320. NTSTATUS
  321. BaseDllCloseIniFileOnDisk(
  322.     IN PINIFILE_PARAMETERS a
  323.     );
  325. NTSTATUS
  326. BaseDllFindSection(
  327.     IN PINIFILE_PARAMETERS a
  328.     );
  330. NTSTATUS
  331. BaseDllFindKeyword(
  332.     IN PINIFILE_PARAMETERS a
  333.     );
  335. NTSTATUS
  336. TermsrvIniSyncLoop( HANDLE SrcHandle,
  337.                 PINIFILE_PARAMETERS a,
  338.                 PBOOLEAN pfIniUpdated
  339.               );
  340. NTSTATUS
  341. TermsrvGetSyncTime( PUNICODE_STRING pSysIniPath,
  342.                 PUNICODE_STRING pUserBasePath,
  343.                 PLARGE_INTEGER  pLastSyncTime
  344.               );
  346. NTSTATUS
  347. TermsrvPutSyncTime( PUNICODE_STRING pSysIniPath,
  348.                 PUNICODE_STRING pUserBasePath,
  349.                 PLARGE_INTEGER  pLastSyncTime
  350.               );
  353. /*****************************************************************************
  354.  *
  355.  *  TermsrvGetSyncTime
  356.  *
  357.  *  This routine will get the time of the system ini file that the user ini
  358.  *  file was last sync'd with.
  359.  *
  360.  * ENTRY:
  361.  *   PUNICODE_STRING pSysIniPath (In) - NT fully qualified system ini path
  362.  *   PUNICODE_STRING pUserBasePath (In) - NT fully qualified user directory path
  363.  *   PLARGE_INTEGER pLastSyncTime (OUT) - ptr to return last sync time
  364.  *
  365.  * EXIT:
  366.  *   STATUS_SUCCESS - successfully retrieved the last sync time from infile.upd
  367.  *
  368.  ****************************************************************************/
  370. NTSTATUS
  371. TermsrvGetSyncTime(
  372.     PUNICODE_STRING pSysIniPath,
  373.     PUNICODE_STRING pUserBasePath,
  374.     PLARGE_INTEGER  pLastSyncTime)
  375. {
  376.     NTSTATUS Status;
  377.     HANDLE   hUpdate = NULL;
  378.     OBJECT_ATTRIBUTES ObjAUpd;
  379.     IO_STATUS_BLOCK   Iosb;
  380.     FILE_STANDARD_INFORMATION StandardInfo;
  381.     WCHAR             wcUpdateFile[MAX_PATH+1];
  382.     UNICODE_STRING    UniUpdateName = {0,
  383.                                        sizeof(wcUpdateFile),
  384.                                        wcUpdateFile};
  385.     PCHAR             pBuff = NULL, pBuffEnd;
  386.     PWCH              pwch;
  387.     SIZE_T            ulBuffSize;
  388.     LONG              lresult;
  390.     wcscpy(wcUpdateFile, pUserBasePath->Buffer);
  391.     wcscat(wcUpdateFile, L"\inifile.upd");
  392.     UniUpdateName.Length = wcslen(wcUpdateFile)*sizeof(WCHAR);
  393.     pLastSyncTime->LowPart = 0;
  394.     pLastSyncTime->HighPart = 0;
  396.     InitializeObjectAttributes( &ObjAUpd,
  397.                                 &UniUpdateName,
  398.                                 OBJ_CASE_INSENSITIVE,
  399.                                 NULL,
  400.                                 NULL
  401.                               );
  403.     // Open the update log
  404.     Iosb.Status = STATUS_SUCCESS;
  405.     Status = NtOpenFile( &hUpdate,
  406.                          FILE_GENERIC_READ,
  407.                          &ObjAUpd,
  408.                          &Iosb,
  409.                          FILE_SHARE_READ|FILE_SHARE_WRITE,
  410.                          FILE_SYNCHRONOUS_IO_NONALERT    // OpenOptions
  411.                        );
  413.     // Get the size of the file
  414.     if (NT_SUCCESS( Status )) {
  415.         Status = NtQueryInformationFile( hUpdate,
  416.                                          &Iosb,
  417.                                          &StandardInfo,
  418.                                          sizeof(StandardInfo),
  419.                                          FileStandardInformation
  420.                                        );
  421.         if (Status == STATUS_BUFFER_OVERFLOW) {
  422.             Status = STATUS_SUCCESS;
  423.         }
  424. #if DBG
  425.         else if (!NT_SUCCESS( Status )) {
  426.             DbgPrint( "TermsrvGetSyncTime: Unable to QueryInformation for %wZ - Status == %xn", &UniUpdateName, Status );
  427.         }
  428. #endif
  429.     }
  431.     if (NT_SUCCESS( Status )) {
  432.         ulBuffSize = StandardInfo.EndOfFile.LowPart + 4 * sizeof(WCHAR);
  433.         Status = NtAllocateVirtualMemory( NtCurrentProcess(),
  434.                                           &pBuff,
  435.                                           0,
  436.                                           &ulBuffSize,
  437.                                           MEM_RESERVE,
  438.                                           PAGE_READWRITE
  439.                                         );
  440.     }
  442.     if (NT_SUCCESS( Status )) {
  443.         Status = NtAllocateVirtualMemory( NtCurrentProcess(),
  444.                                           &pBuff,
  445.                                           0,
  446.                                           &ulBuffSize,
  447.                                           MEM_COMMIT,
  448.                                           PAGE_READWRITE
  449.                                         );
  450.     }
  452.     if (NT_SUCCESS( Status )) {
  453.         Status = NtReadFile( hUpdate,
  454.                              NULL,
  455.                              NULL,
  456.                              NULL,
  457.                              &Iosb,
  458.                              pBuff,
  459.                              StandardInfo.EndOfFile.LowPart,
  460.                              NULL,
  461.                              NULL
  462.                            );
  464.         if ( Status == STATUS_PENDING ) {
  465.             Status = NtWaitForSingleObject( hUpdate, FALSE, NULL );
  466.         }
  468.         if ( NT_SUCCESS(Status) ) {
  469.             // Get final I/O status
  470.             Status = Iosb.Status;
  471.         }
  472.     }
  474.     // Look for this ini file in the list
  475.     if (NT_SUCCESS(Status)) {
  477.         pwch = (PWCHAR)pBuff;
  478.         pBuffEnd = pBuff + StandardInfo.EndOfFile.LowPart;
  480.         // Look for the file in the sorted list
  481.         while ((pwch < (PWCHAR)pBuffEnd) &&
  482.                ((lresult = _wcsicmp(pwch, pSysIniPath->Buffer)) < 0)) {
  483.             pwch += wcslen(pwch) + sizeof(LARGE_INTEGER)/sizeof(WCHAR) + 1;
  484.         }
  486.         if ((pwch < (PWCHAR)pBuffEnd) && (lresult == 0)) {
  487.             pwch += wcslen(pwch) + 1;
  488.             pLastSyncTime->LowPart = ((PLARGE_INTEGER)pwch)->LowPart;
  489.             pLastSyncTime->HighPart = ((PLARGE_INTEGER)pwch)->HighPart;
  490.         }
  491.     }
  493.     if (NT_SUCCESS(Status) ) {
  494.         // Get final I/O status
  495.         Status = Iosb.Status;
  496.     }
  498.     if (pBuff) {
  499.         NtFreeVirtualMemory( NtCurrentProcess(),
  500.                              &pBuff,
  501.                              &ulBuffSize,
  502.                              MEM_RELEASE
  503.                            );
  504.     }
  506.     if (hUpdate) {
  507.         Status = NtClose( hUpdate );
  508.     }
  509.     return(Status);
  510. }
  513. /*****************************************************************************
  514.  *
  515.  *  TermsrvPutSyncTime
  516.  *
  517.  *  This routine will write the time of the system ini file that the user ini
  518.  *  file was last sync'd with.
  519.  *
  520.  * ENTRY:
  521.  *   PUNICODE_STRING pSysIniPath (In) - NT fully qualified system ini path
  522.  *   PUNICODE_STRING pUserBasePath (In) - NT fully qualified user directory path
  523.  *   PLARGE_INTEGER pLastSyncTime (OUT) - ptr to return last sync time
  524.  *
  525.  * EXIT:
  526.  *   STATUS_SUCCESS - successfully stored the last sync time in infile.upd
  527.  *
  528.  ****************************************************************************/
  530. NTSTATUS
  531. TermsrvPutSyncTime(
  532.     PUNICODE_STRING pSysIniPath,
  533.     PUNICODE_STRING pUserBasePath,
  534.     PLARGE_INTEGER  pLastSyncTime)
  535. {
  536.     NTSTATUS Status;
  537.     HANDLE   hUpdate = NULL;
  538.     OBJECT_ATTRIBUTES ObjAUpd;
  539.     IO_STATUS_BLOCK   Iosb;
  540.     FILE_STANDARD_INFORMATION StandardInfo;
  541.     WCHAR             wcUpdateFile[MAX_PATH+1];
  542.     UNICODE_STRING    UniUpdateName = {0,
  543.                                        sizeof(wcUpdateFile),
  544.                                        wcUpdateFile};
  545.     PCHAR             pBuff = NULL, pBuffEnd;
  546.     PWCH              pwch;
  547.     SIZE_T            ulBuffSize;
  548.     ULONG             ulLength;
  549.     SIZE_T            ulRegionSize;
  550.     LONG              lresult;
  551.     LARGE_INTEGER     FileLength;
  552.     FILE_POSITION_INFORMATION CurrentPos;
  554.     wcscpy(wcUpdateFile, pUserBasePath->Buffer);
  555.     wcscat(wcUpdateFile, L"\inifile.upd");
  556.     UniUpdateName.Length = wcslen(wcUpdateFile)*sizeof(WCHAR);
  558.     InitializeObjectAttributes( &ObjAUpd,
  559.                                 &UniUpdateName,
  560.                                 OBJ_CASE_INSENSITIVE,
  561.                                 NULL,
  562.                                 NULL
  563.                               );
  565.     // Open the update log
  566.     Iosb.Status = STATUS_SUCCESS;
  567.     Status = NtCreateFile( &hUpdate,
  568.                              FILE_READ_DATA | FILE_WRITE_DATA |
  569.                                FILE_READ_ATTRIBUTES | SYNCHRONIZE,
  570.                              &ObjAUpd,
  571.                              &Iosb,
  572.                            NULL,                  // Allocation size
  573.                            FILE_ATTRIBUTE_NORMAL, // dwFlagsAndAttributes
  574.                              FILE_SHARE_WRITE,      // dwShareMode
  575.                            FILE_OPEN_IF,          // CreateDisposition
  576.                              FILE_SYNCHRONOUS_IO_NONALERT |
  577.                                FILE_NON_DIRECTORY_FILE, // CreateFlags
  578.                            NULL, // EaBuffer
  579.                            0     // EaLength
  580.                            );
  582.     if (NT_SUCCESS( Status )) {
  583.         Status = NtQueryInformationFile( hUpdate,
  584.                                          &Iosb,
  585.                                          &StandardInfo,
  586.                                          sizeof(StandardInfo),
  587.                                          FileStandardInformation
  588.                                        );
  589.         if (Status == STATUS_BUFFER_OVERFLOW) {
  590.             Status = STATUS_SUCCESS;
  591.         }
  592. #if DBG
  593.         else if (!NT_SUCCESS( Status )) {
  594.             DbgPrint( "TermsrvGetLastSyncTime: Unable to QueryInformation for %wZ - Status == %xn", &UniUpdateName, Status );
  595.         }
  596. #endif
  597.     }
  599.     if (NT_SUCCESS( Status )) {
  600.         ulBuffSize = StandardInfo.EndOfFile.LowPart + 4 * sizeof(WCHAR);
  601.         ulRegionSize = ulBuffSize + 0x1000; // Room for 4K of growth
  602.         Status = NtAllocateVirtualMemory( NtCurrentProcess(),
  603.                                           &pBuff,
  604.                                           0,
  605.                                           &ulRegionSize,
  606.                                           MEM_RESERVE,
  607.                                           PAGE_READWRITE
  608.                                         );
  609.     }
  611.     if (NT_SUCCESS( Status )) {
  612.         Status = NtAllocateVirtualMemory( NtCurrentProcess(),
  613.                                           &pBuff,
  614.                                           0,
  615.                                           &ulBuffSize,
  616.                                           MEM_COMMIT,
  617.                                           PAGE_READWRITE
  618.                                         );
  619.     }
  621.     if (NT_SUCCESS( Status ) && StandardInfo.EndOfFile.LowPart) {
  622.         Status = NtReadFile( hUpdate,
  623.                              NULL,
  624.                              NULL,
  625.                              NULL,
  626.                              &Iosb,
  627.                              pBuff,
  628.                              StandardInfo.EndOfFile.LowPart,
  629.                              NULL,
  630.                              NULL
  631.                            );
  633.         if ( Status == STATUS_PENDING ) {
  634.             Status = NtWaitForSingleObject( hUpdate, FALSE, NULL );
  635.         }
  637.         if ( NT_SUCCESS(Status) ) {
  638.             // Get final I/O status
  639.             Status = Iosb.Status;
  640.         }
  641.     }
  643.     // Look for this ini file in the list
  644.     if (NT_SUCCESS(Status)) {
  646.         pwch = (PWCHAR)pBuff;
  647.         pBuffEnd = pBuff + StandardInfo.EndOfFile.LowPart;
  649.         // Look for the file in the list
  650.         while ((pwch < (PWCHAR)pBuffEnd) &&
  651.                ((lresult = _wcsicmp(pwch, pSysIniPath->Buffer)) < 0)) {
  652.             pwch += wcslen(pwch) + (sizeof(LARGE_INTEGER)/sizeof(WCHAR)) + 1;
  653.         }
  655.         // If the ini file is already in the file, just update the time
  656.         if ((pwch < (PWCHAR)pBuffEnd) && (lresult == 0)) {
  657.             pwch += wcslen(pwch) + 1;
  658.             ((PLARGE_INTEGER)pwch)->LowPart = pLastSyncTime->LowPart;
  659.             ((PLARGE_INTEGER)pwch)->HighPart = pLastSyncTime->HighPart;
  661.         } else {                    // Ini file not in list
  663.             // Figure out the size to grow the file
  664.             ulLength = (pSysIniPath->Length + 2) + sizeof(LARGE_INTEGER);
  665.             ulBuffSize += ulLength;
  667.             // Grow the memory region
  668.             Status = NtAllocateVirtualMemory( NtCurrentProcess(),
  669.                                               &pBuff,
  670.                                               0,
  671.                                               &ulBuffSize,
  672.                                               MEM_COMMIT,
  673.                                               PAGE_READWRITE
  674.                                             );
  676.             if (NT_SUCCESS(Status)) {
  677.                 // figure out where the entry goes in the file
  678.                 if (pwch < (PWCHAR)pBuffEnd) {
  679.                     RtlMoveMemory( pwch+(ulLength/sizeof(WCHAR)),
  680.                                    pwch,
  681.                                    pBuffEnd - (PCHAR)pwch
  682.                                  );
  683.                 }
  685.                 pBuffEnd += ulLength;
  686.                 wcscpy(pwch, pSysIniPath->Buffer);
  687.                 pwch += (pSysIniPath->Length + 2)/sizeof(WCHAR);
  688.                 ((PLARGE_INTEGER)pwch)->LowPart = pLastSyncTime->LowPart;
  689.                 ((PLARGE_INTEGER)pwch)->HighPart = pLastSyncTime->HighPart;
  690.             }
  691.         }
  692.     }
  694.     if (NT_SUCCESS(Status)) {
  695.         CurrentPos.CurrentByteOffset.LowPart = 0;
  696.         CurrentPos.CurrentByteOffset.HighPart = 0;
  697.         Status = NtSetInformationFile( hUpdate,
  698.                                        &Iosb,
  699.                                        &CurrentPos,
  700.                                        sizeof(CurrentPos),
  701.                                        FilePositionInformation
  702.                                      );
  704.         Status = NtWriteFile( hUpdate,
  705.                               NULL,
  706.                               NULL,
  707.                               NULL,
  708.                               &Iosb,
  709.                               pBuff,
  710.                               (ULONG)(pBuffEnd - pBuff + 1),
  711.                               NULL,
  712.                               NULL
  713.                             );
  715.         if( Status == STATUS_PENDING ) {
  716.             Status = NtWaitForSingleObject( hUpdate, FALSE, NULL );
  717.         }
  719.         if( NT_SUCCESS(Status) ) {
  720.             // Get final I/O status
  721.             Status = Iosb.Status;
  722.         }
  723.     }
  725.     if (NT_SUCCESS( Status )) {
  726.         FileLength.LowPart = (ULONG)(pBuffEnd - pBuff);
  727.         FileLength.HighPart = 0;
  728.         Status = NtSetInformationFile( hUpdate,
  729.                                        &Iosb,
  730.                                        &FileLength,
  731.                                        sizeof( FileLength ),
  732.                                        FileEndOfFileInformation
  733.                                      );
  734.     }
  736.     if (pBuff) {
  737.         NtFreeVirtualMemory( NtCurrentProcess(),
  738.                              &pBuff,
  739.                              &ulRegionSize,
  740.                              MEM_RELEASE
  741.                            );
  742.     }
  744.     if (hUpdate) {
  745.         Status = NtClose( hUpdate );
  746.     }
  748.     return(Status);
  749. }
  752. /*****************************************************************************
  753.  *
  754.  *  TermsrvCheckIniSync
  755.  *
  756.  *  This routine will get the time of the system ini file that the user ini
  757.  *  file was last sync'd with.
  758.  *
  759.  * ENTRY:
  760.  *   PUNICODE_STRING pSysIniPath (In) - NT fully qualified system ini path
  761.  *   PUNICODE_STRING pUserBasePath (In) - NT fully qualified user directory path
  762.  *   BOOLEAN fGet (In) - TRUE means to get last sync time, FALSE means to write it
  763.  *   PLARGE_INTEGER pLastSyncTime (OUT) - ptr to return last sync time
  764.  *
  765.  * EXIT:
  766.  *   TRUE  - User ini file should be sync'd
  767.  *   FALSE - User ini file should be sync'd
  768.  *
  769.  ****************************************************************************/
  771. BOOLEAN
  772. TermsrvCheckIniSync(
  773.     PUNICODE_STRING pSysIniPath,
  774.     PUNICODE_STRING pUserBasePath)
  775. {
  776.     LARGE_INTEGER          LastSyncTime;
  777.     OBJECT_ATTRIBUTES      objaIni;
  778.     FILE_NETWORK_OPEN_INFORMATION BasicInfo;
  779.     NTSTATUS               Status;
  781.     // Get the last sync time of the ini file from the inifile.upd file
  782.     TermsrvGetSyncTime(pSysIniPath, pUserBasePath, &LastSyncTime);
  784.     // Get the last write time of the system ini file
  785.     InitializeObjectAttributes(
  786.         &objaIni,
  787.         pSysIniPath,
  788.         OBJ_CASE_INSENSITIVE,
  789.         NULL,
  790.         NULL
  791.         );
  793.     // Now query it
  794.     Status = NtQueryFullAttributesFile( &objaIni, &BasicInfo );
  796.     // If we couldn't get the time or the system ini file has been updated
  797.     // since we last sync'd, return TRUE
  798.     if (!NT_SUCCESS(Status) ||
  799.         ((BasicInfo.LastWriteTime.HighPart > LastSyncTime.HighPart) ||
  800.          ((BasicInfo.LastWriteTime.HighPart == LastSyncTime.HighPart) &&
  801.          (BasicInfo.LastWriteTime.LowPart > LastSyncTime.LowPart)))) {
  802.         return(TRUE);
  803.     }
  804.     return(FALSE);
  805. }
  806. /*****************************************************************************
  807.  *
  808.  *  TermsrvDoesFileExist
  809.  *
  810.  *   Returns whether the file exists or not.
  811.  *
  812.  *   Must use NT, not WIN32 pathnames.
  813.  *
  814.  * ENTRY:
  815.  *   Param1 (input/output)
  816.  *     Comments
  817.  *
  818.  * EXIT:
  819.  *   STATUS_SUCCESS - no error
  820.  *
  821.  ****************************************************************************/
  823. BOOL
  824. TermsrvDoesFileExist(
  825.     PUNICODE_STRING pFileName
  826.     )
  827. {
  828.     NTSTATUS Status;
  829.     FILE_BASIC_INFORMATION BasicInfo;
  830.     OBJECT_ATTRIBUTES Obja;
  832.     InitializeObjectAttributes(
  833.         &Obja,
  834.         pFileName,
  835.         OBJ_CASE_INSENSITIVE,
  836.         NULL,
  837.         NULL
  838.         );
  840.     /*
  841.      * Now query it
  842.      */
  843.     Status = NtQueryAttributesFile( &Obja, &BasicInfo );
  845.     if( NT_SUCCESS( Status ) ) {
  846.         return( TRUE );
  847.     }
  849.     return( FALSE );
  850. }
  854. /*****************************************************************************
  855.  *
  856.  *  TermsrvSyncUserIniFile
  857.  *
  858.  *   This routine will check that the user's ini file is "sync'd" with the
  859.  *   system version of the ini file.  This means that it walks through the
  860.  *   system ini file and checks that there is a corresponding entry in the
  861.  *   user's ini file.
  862.  *
  863.  * ENTRY:
  864.  *   IN PINIFILE_PARAMETERS a - ptr to inifile structure
  865.  *
  866.  * EXIT:
  867.  *   True  - Ini file updated
  868.  *   False - User Ini file was unchanged
  869.  *
  870.  ****************************************************************************/
  871. BOOL TermsrvSyncUserIniFile(PINIFILE_PARAMETERS a)
  872. {
  873.     WCHAR          wcIniPath[MAX_PATH+1];
  874.     UNICODE_STRING IniFilePath = {MAX_PATH,
  875.                                   MAX_PATH+1,
  876.                                   wcIniPath};
  877.     PWCH           pwch, pwcIniName;
  878.     UNICODE_STRING UniSysPath;
  879.     UNICODE_STRING UserBasePath;
  880.     NTSTATUS       Status;
  881.     HANDLE         SrcHandle;
  882.     ULONG          ulCompatFlags;
  883.     OBJECT_ATTRIBUTES SrcObja;
  884.     IO_STATUS_BLOCK   SrcIosb;
  885.     INIFILE_OPERATION OrigOperation;
  886.     BOOLEAN           OrigWrite, OrigMultiValue, OrigUnicode,
  887.                       OrigWriteOperation, fIniUpdated = FALSE;
  888.     ANSI_STRING       OrigAppName, OrigVarName;
  889.     ULONG             OrigResultChars, OrigResultMaxChars;
  890.     LPSTR             OrigResultBuffer;
  891.     OBJECT_ATTRIBUTES      objaIni;
  892.     FILE_NETWORK_OPEN_INFORMATION BasicInfo;
  894.     // If INI file mapping is not on, return
  895.     if (IsSystemLUID() || TermsrvAppInstallMode()) {
  896.         return(FALSE);
  897.     }
  899.     // Build full system path to the Ini file, and get BasePath to user dir
  900.     if ((gpTermsrvBuildSysIniPath == NULL) || !(gpTermsrvBuildSysIniPath(&a->NtFileName, &UniSysPath, &UserBasePath))) {
  901.         #if DBG
  902.         //DbgPrint("TermsrvSyncUserIniFile: Error building Sys Ini Path!n");
  903.         #endif
  904.         return(FALSE);
  905.     }
  907.     // Get the ini file name
  908.     pwch = wcsrchr(a->NtFileName.Buffer, L'\') + 1;
  909.     pwcIniName = RtlAllocateHeap( RtlProcessHeap(),
  910.                                   0,
  911.                                   (wcslen(pwch) + 1)*sizeof(WCHAR));
  912.     wcscpy(pwcIniName, pwch);
  913.     pwch = wcsrchr(pwcIniName, L'.');
  914.     if (pwch) {
  915.         *pwch = L'';
  916.     }
  918.     if (gpGetTermsrCompatFlags) {
  919.         gpGetTermsrCompatFlags(pwcIniName, &ulCompatFlags, CompatibilityIniFile);
  920.     } else {
  921.         return FALSE;
  922.     }
  924.     // If the INISYNC compatibility flag is set in the registry and the
  925.     // system version of the ini file exists, sync up the user version
  926.     if (((ulCompatFlags & (TERMSRV_COMPAT_INISYNC | TERMSRV_COMPAT_WIN16)) ==
  927.          (TERMSRV_COMPAT_INISYNC | TERMSRV_COMPAT_WIN16)) &&
  928.         TermsrvDoesFileExist(&UniSysPath) &&
  929.         TermsrvCheckIniSync(&UniSysPath, &UserBasePath)) {
  931.         // Create a backup copy of the original file (inifile.ctx)
  932.         wcscpy(wcIniPath, UserBasePath.Buffer);
  933.         if (UserBasePath.Buffer[UserBasePath.Length/sizeof(WCHAR) - 1] != L'\')
  934.             wcscat(wcIniPath, L"\");
  935.         wcscat(wcIniPath, pwcIniName);
  936.         wcscat(wcIniPath, L".ctx");
  937.         IniFilePath.Length = wcslen(wcIniPath)*sizeof(WCHAR);
  939.         if (gpTermsrvCopyIniFile) {
  940.             Status = gpTermsrvCopyIniFile(&a->NtFileName, NULL, &IniFilePath);
  941.     #if DBG
  942.             if (!NT_SUCCESS(Status)) {
  943.                 DbgPrint("TermsrvSyncUserIniFile: Error 0x%x creating backup ini file %wsn",
  944.                          Status,
  945.                          wcIniPath);
  946.             }
  947.     #endif
  948.         } else {
  949.             return FALSE;
  950.             }
  952.         // Check that each entry in the system version is in the user's version
  953.         InitializeObjectAttributes(&SrcObja,
  954.                                    &UniSysPath,
  955.                                    OBJ_CASE_INSENSITIVE,
  956.                                    NULL,
  957.                                    NULL);
  959.         // Open the src
  960.         SrcIosb.Status = STATUS_SUCCESS;
  961.         Status = NtOpenFile(&SrcHandle,
  962.                              FILE_GENERIC_READ,
  963.                             &SrcObja,
  964.                             &SrcIosb,
  965.                             FILE_SHARE_READ|FILE_SHARE_WRITE,
  966.                             FILE_SYNCHRONOUS_IO_NONALERT);
  968.         if( NT_SUCCESS(Status) ) {
  969.             // Get final I/O status
  970.                   Status = SrcIosb.Status;
  971.         }
  973.         if( !NT_SUCCESS(Status) ) {
  974. #if DBG
  975.             DbgPrint("TermsrvSyncUserIniFile: Error 0x%x opening SrcFile %wsn",
  976.                      Status,
  977.                      &UniSysPath.Buffer);
  978. #endif
  979.             goto Cleanup;
  980.         }
  982.         // Save the original values
  983.         OrigOperation = a->Operation;
  984.         OrigMultiValue = a->MultiValueStrings;
  985.         OrigAppName = a->ApplicationName;
  986.         OrigVarName = a->VariableName;
  987.         OrigResultChars = a->ResultChars;
  988.         OrigResultMaxChars = a->ResultMaxChars;
  989.         OrigResultBuffer = a->ResultBuffer;
  990.         OrigUnicode = a->Unicode;
  991.         OrigWriteOperation = a->WriteOperation;
  993.         // Set up the open for writes
  994.         a->WriteOperation = TRUE;
  995.         a->Operation = WriteKeyValue;
  996.         a->MultiValueStrings = FALSE;
  997.         a->Unicode = FALSE;
  999.         Status = BaseDllOpenIniFileOnDisk( a );
  1001.         if( !NT_SUCCESS(Status) ) {
  1002. #if DBG
  1003.             DbgPrint("TermsrvSyncUserIniFile: Error 0x%x opening DestFile %wsn",
  1004.                      Status,
  1005.                      &a->NtFileName.Buffer);
  1006. #endif
  1007.             NtClose( SrcHandle );
  1008.                 goto Cleanup;
  1009.         }
  1011.         // set the data up for writing
  1012.         a->TextEnd = (PCHAR)a->IniFile->BaseAddress +
  1013.                             a->IniFile->EndOfFile;
  1014.         a->TextCurrent = a->IniFile->BaseAddress;
  1016.         // Make sure entries in system ini file are in user ini file
  1017.         Status = TermsrvIniSyncLoop( SrcHandle, a, &fIniUpdated );
  1018. #if DBG
  1019.         if( !NT_SUCCESS(Status) ) {
  1020.             DbgPrint("TermsrvSyncUserIniFile: Error 0x%x Doing sync loopn",Status);
  1021.         }
  1022. #endif
  1024.         // Close the file handles
  1025.         NtClose( SrcHandle );
  1026.         BaseDllCloseIniFileOnDisk( a );
  1028.         // Restore the variables in the ini file structure
  1029.         a->Operation = OrigOperation;
  1030.         a->MultiValueStrings = OrigMultiValue;
  1031.         a->ApplicationName = OrigAppName;
  1032.         a->VariableName = OrigVarName;
  1033.         a->ResultChars = OrigResultChars;
  1034.         a->ResultMaxChars = OrigResultMaxChars;
  1035.         a->ResultBuffer = OrigResultBuffer;
  1036.         a->WriteOperation = FALSE;
  1037.         a->Unicode = OrigUnicode;
  1038.         a->WriteOperation = OrigWriteOperation;
  1040.         // Get the last write time of the system ini file
  1041.         InitializeObjectAttributes( &objaIni,
  1042.                                     &UniSysPath,
  1043.                                     OBJ_CASE_INSENSITIVE,
  1044.                                     NULL,
  1045.                                     NULL
  1046.                                   );
  1048.         // Now query it
  1049.         Status = NtQueryFullAttributesFile( &objaIni, &BasicInfo );
  1051.         // Update the sync time in the inisync file
  1052.         if (NT_SUCCESS(Status)) {
  1053.             TermsrvPutSyncTime( &UniSysPath,
  1054.                             &UserBasePath,
  1055.                             &BasicInfo.LastWriteTime
  1056.                           );
  1057.         }
  1058.     }
  1060. Cleanup:
  1061.     // Free the unicode buffers
  1062.     RtlFreeHeap( RtlProcessHeap(), 0, UniSysPath.Buffer );
  1063.     RtlFreeHeap( RtlProcessHeap(), 0, UserBasePath.Buffer );
  1064.     RtlFreeHeap( RtlProcessHeap(), 0, pwcIniName);
  1066.     return(fIniUpdated);
  1067. }
  1070. /*****************************************************************************
  1071.  *
  1072.  *  TermsrvIniSyncLoop
  1073.  *
  1074.  *  This routine will verify that there's a corresponding entry in the user's
  1075.  *  ini file for each entry in the system ini file.
  1076.  *
  1077.  * ENTRY:
  1078.  *   HANDLE SrcHandle (INPUT)  - Handle to system ini file
  1079.  *   PINIFILE_PARAMETERS a (INPUT) - pointer to current ini file structure
  1080.  *   PBOOLEAN pfIniUpdated (OUTPUT) - Returns TRUE if user ini file is modified
  1081.  *
  1082.  * EXIT:
  1083.  *   STATUS_SUCCESS - no error
  1084.  *
  1085.  ****************************************************************************/
  1087. NTSTATUS
  1088. TermsrvIniSyncLoop(HANDLE SrcHandle,
  1089.                PINIFILE_PARAMETERS a,
  1090.                PBOOLEAN pfIniUpdated)
  1091. {
  1092.     PCHAR pStr;
  1093.     NTSTATUS Status;
  1094.     ULONG StringSize;
  1095.     CHAR  IOBuf[512];
  1096.     ULONG IOBufSize = 512;
  1097.     ULONG IOBufIndex = 0;
  1098.     ULONG IOBufFillSize = 0;
  1099.     ANSI_STRING AnsiSection;
  1100.     PCH pch;
  1101.     PVOID pSection, origbase;
  1103.     AnsiSection.Buffer = NULL;
  1104.     *pfIniUpdated = FALSE;
  1106.     while( 1 ) {
  1108.         pStr = NULL;
  1109.         StringSize = 0;
  1111.         if (gpTermsrvGetString == NULL) {
  1112.             return STATUS_UNSUCCESSFUL;
  1113.         }
  1115.         // Get a string from the source ini file
  1116.         Status = gpTermsrvGetString(SrcHandle,
  1117.                                &pStr,
  1118.                                &StringSize,
  1119.                                IOBuf,
  1120.                                IOBufSize,
  1121.                               &IOBufIndex,
  1122.                                &IOBufFillSize);
  1124.         if( !NT_SUCCESS(Status) ) {
  1126.             ASSERT( pStr == NULL );
  1128.             if( Status == STATUS_END_OF_FILE ) {
  1129.                 Status = STATUS_SUCCESS;
  1130.             }
  1131.             if (AnsiSection.Buffer) {
  1132.                 RtlFreeHeap( RtlProcessHeap(), 0, AnsiSection.Buffer );
  1133.             }
  1135.             a->IniFile->UpdateEndOffset = a->IniFile->EndOfFile;
  1136.             return( Status );
  1137.         }
  1139.         // Make sure we got some actual data
  1140.         ASSERT( pStr != NULL );
  1142.         // Is this a section name?
  1143.         if (*pStr == '[') {
  1144.             if (AnsiSection.Buffer) {
  1145.                 RtlFreeHeap( RtlProcessHeap(), 0, AnsiSection.Buffer );
  1146.                 AnsiSection.Buffer = NULL;
  1147.             }
  1148.             pch = strrchr(pStr, ']');
  1149.             if (pch) {
  1150.                 AnsiSection.MaximumLength = (USHORT)(pch - pStr);
  1151.                 *pch = '';
  1152.             } else {
  1153.                 AnsiSection.Length = strlen(pStr);
  1154.             }
  1155.             AnsiSection.Length = AnsiSection.MaximumLength - 1;
  1156.             AnsiSection.Buffer = RtlAllocateHeap(RtlProcessHeap(),
  1157.                                                  0,
  1158.                                                  AnsiSection.MaximumLength);
  1159.             strcpy(AnsiSection.Buffer, pStr+1);
  1160.             a->ApplicationName = AnsiSection;
  1162.             a->TextCurrent = a->IniFile->BaseAddress;   // reset file pointer
  1164.             // See if the section already exists, if so save the start of it
  1165.             Status = BaseDllFindSection( a );
  1166.             if (NT_SUCCESS(Status)) {
  1167.                 pSection = a->TextCurrent;
  1168.             } else {
  1169.                 pSection = NULL;
  1170.             }
  1172.         // If it's not a comment, see if the entry is in the user's ini file
  1173.         } else if (*pStr != ';') {
  1175.             pch = strchr(pStr, '=');
  1176.             if (pch) {
  1177.                 a->VariableName.Length = a->VariableName.MaximumLength =
  1178.                     (USHORT)(pch - pStr);
  1179.                 a->VariableName.Buffer = pStr;
  1180.                 a->ValueBuffer = (++pch);
  1181.                 a->ValueLength = 0;
  1182.                 while (*pch && (*pch != 0xa) && (*pch != 0xd)) {
  1183.                     pch++;
  1184.                     a->ValueLength++;
  1185.                 }
  1188.                 // If the section exists, check for the keyword in user's ini
  1189.                 if (pSection) {
  1190.                     a->TextCurrent = pSection;
  1191.                     Status = BaseDllFindKeyword( a );
  1192.                 }
  1194.                 // If variable isn't found, write it out
  1195.                 if (!pSection || !NT_SUCCESS( Status )) {
  1197.                     origbase = a->TextCurrent = a->IniFile->BaseAddress;
  1198.                     Status = BaseDllWriteKeywordValue( a, NULL );
  1199.                     a->TextEnd = (PCHAR)a->IniFile->BaseAddress +
  1200.                                         a->IniFile->EndOfFile;
  1201.                     if (!NT_SUCCESS(Status)) {
  1202.                               #if DBG
  1203.                               DbgPrint("TermsrvIniSyncLoop: Error 0x%x write Key Valuen",
  1204.                                   Status);
  1205.                               #endif
  1206.                         a->IniFile->UpdateEndOffset = a->IniFile->EndOfFile;
  1207.                         RtlFreeHeap( RtlProcessHeap(), 0, pStr );
  1208.                         if (AnsiSection.Buffer) {
  1209.                             RtlFreeHeap(RtlProcessHeap(),
  1210.                                         0,
  1211.                                         AnsiSection.Buffer);
  1212.                         }
  1213.                         return(Status);
  1214.                     }
  1215.                     *pfIniUpdated = TRUE;
  1216.                     if (origbase != a->IniFile->BaseAddress) {
  1217.                         a->TextCurrent = a->IniFile->BaseAddress;
  1218.                         Status = BaseDllFindSection( a );
  1219.                         if (NT_SUCCESS(Status)) {
  1220.                             pSection = a->TextCurrent;
  1221.                         } else {
  1222.                             pSection = NULL;
  1223.                         }
  1224.                     }
  1225.                 }
  1226.             }
  1227.         }
  1230.     } // end while(1)
  1231. }