Category

Development Platform
Home > SourceCode/Document > Windows Develop > View Code
registry.c
Package: win2ksrc.rar　[view]
Upload User: caisha3
Upload Date: 2013-09-21
Package Size: 208739k
Code Size: 24k
Category:

Windows Develop

Development Platform:

Visual C++

registry.c：Code Content
  1. /*++
  3. Copyright (c) 1990  Microsoft Corporation
  5. Module Name:
  7.     registry.c
  9. Abstract:
  11.     This file contains functions to read and _rite values
  12.     to the registry.
  14. Author:
  16.     Jerry Shea (JerrySh) 30-Sep-1994
  18. Revision History:
  20. --*/
  22. #include "precomp.h"
  23. #pragma hdrstop
  26. #define CONSOLE_REGISTRY_CURRENTPAGE  (L"CurrentPage")
  29. NTSTATUS
  30. MyRegOpenKey(
  31.     IN HANDLE hKey,
  32.     IN LPWSTR lpSubKey,
  33.     OUT PHANDLE phResult
  34.     )
  35. {
  36.     OBJECT_ATTRIBUTES   Obja;
  37.     UNICODE_STRING      SubKey;
  39.     //
  40.     // Convert the subkey to a counted Unicode string.
  41.     //
  43.     RtlInitUnicodeString( &SubKey, lpSubKey );
  45.     //
  46.     // Initialize the OBJECT_ATTRIBUTES structure and open the key.
  47.     //
  49.     InitializeObjectAttributes(
  50.         &Obja,
  51.         &SubKey,
  52.         OBJ_CASE_INSENSITIVE,
  53.         hKey,
  54.         NULL
  55.         );
  57.     return NtOpenKey(
  58.               phResult,
  59.               KEY_READ,
  60.               &Obja
  61.               );
  62. }
  64. NTSTATUS
  65. MyRegDeleteKey(
  66.     IN HANDLE hKey,
  67.     IN LPWSTR lpSubKey
  68.     )
  69. {
  70.     UNICODE_STRING      SubKey;
  72.     //
  73.     // Convert the subkey to a counted Unicode string.
  74.     //
  76.     RtlInitUnicodeString( &SubKey, lpSubKey );
  78.     //
  79.     // Delete the subkey
  80.     //
  82.     return NtDeleteValueKey(
  83.               hKey,
  84.               &SubKey
  85.               );
  86. }
  88. NTSTATUS
  89. MyRegCreateKey(
  90.     IN HANDLE hKey,
  91.     IN LPWSTR lpSubKey,
  92.     OUT PHANDLE phResult
  93.     )
  94. {
  95.     OBJECT_ATTRIBUTES   Obja;
  96.     UNICODE_STRING      SubKey;
  98.     //
  99.     // Convert the subkey to a counted Unicode string.
  100.     //
  102.     RtlInitUnicodeString( &SubKey, lpSubKey );
  104.     //
  105.     // Initialize the OBJECT_ATTRIBUTES structure and open the key.
  106.     //
  108.     InitializeObjectAttributes(
  109.         &Obja,
  110.         &SubKey,
  111.         OBJ_CASE_INSENSITIVE,
  112.         hKey,
  113.         NULL
  114.         );
  116.     return NtCreateKey(
  117.                     phResult,
  118.                     KEY_READ | KEY_WRITE,
  119.                     &Obja,
  120.                     0,
  121.                     NULL,
  122.                     0,
  123.                     NULL
  124.                     );
  125. }
  127. NTSTATUS
  128. MyRegQueryValue(
  129.     IN HANDLE hKey,
  130.     IN LPWSTR lpValueName,
  131.     IN DWORD dwValueLength,
  132.     OUT LPBYTE lpData
  133.     )
  134. {
  135.     UNICODE_STRING ValueName;
  136.     ULONG BufferLength;
  137.     ULONG ResultLength;
  138.     PKEY_VALUE_PARTIAL_INFORMATION KeyValueInformation;
  139.     NTSTATUS Status;
  141.     //
  142.     // Convert the subkey to a counted Unicode string.
  143.     //
  145.     RtlInitUnicodeString( &ValueName, lpValueName );
  147.     BufferLength = FIELD_OFFSET(KEY_VALUE_PARTIAL_INFORMATION, Data) + dwValueLength;
  148.     KeyValueInformation = HeapAlloc(RtlProcessHeap(),0,BufferLength);
  149.     if (KeyValueInformation == NULL)
  150.         return STATUS_NO_MEMORY;
  152.     Status = NtQueryValueKey(
  153.                 hKey,
  154.                 &ValueName,
  155.                 KeyValuePartialInformation,
  156.                 KeyValueInformation,
  157.                 BufferLength,
  158.                 &ResultLength
  159.                 );
  160.     if (NT_SUCCESS(Status)) {
  161.         ASSERT(KeyValueInformation->DataLength <= dwValueLength);
  162.         RtlCopyMemory(lpData,
  163.             KeyValueInformation->Data,
  164.             KeyValueInformation->DataLength);
  165.         if (KeyValueInformation->Type == REG_SZ) {
  166.             if (KeyValueInformation->DataLength + sizeof(WCHAR) > dwValueLength) {
  167.                 KeyValueInformation->DataLength -= sizeof(WCHAR);
  168.             }
  169.             lpData[KeyValueInformation->DataLength++] = 0;
  170.             lpData[KeyValueInformation->DataLength] = 0;
  171.         }
  172.     }
  173.     HeapFree(RtlProcessHeap(),0,KeyValueInformation);
  174.     return Status;
  175. }
  178. #if defined(FE_SB)
  179. NTSTATUS
  180. MyRegEnumValue(
  181.     IN HANDLE hKey,
  182.     IN DWORD dwIndex,
  183.     OUT DWORD dwValueLength,
  184.     OUT LPWSTR lpValueName,
  185.     OUT DWORD dwDataLength,
  186.     OUT LPBYTE lpData
  187.     )
  188. {
  189.     ULONG BufferLength;
  190.     ULONG ResultLength;
  191.     PKEY_VALUE_FULL_INFORMATION KeyValueInformation;
  192.     NTSTATUS Status;
  194.     //
  195.     // Convert the subkey to a counted Unicode string.
  196.     //
  198.     BufferLength = sizeof(KEY_VALUE_FULL_INFORMATION) + dwValueLength + dwDataLength;
  199.     KeyValueInformation = LocalAlloc(LPTR,BufferLength);
  200.     if (KeyValueInformation == NULL)
  201.         return STATUS_NO_MEMORY;
  203.     Status = NtEnumerateValueKey(
  204.                 hKey,
  205.                 dwIndex,
  206.                 KeyValueFullInformation,
  207.                 KeyValueInformation,
  208.                 BufferLength,
  209.                 &ResultLength
  210.                 );
  211.     if (NT_SUCCESS(Status)) {
  212.         ASSERT(KeyValueInformation->NameLength <= dwValueLength);
  213.         RtlMoveMemory(lpValueName,
  214.                       KeyValueInformation->Name,
  215.                       KeyValueInformation->NameLength);
  216.         lpValueName[ KeyValueInformation->NameLength >> 1 ] = UNICODE_NULL;
  219.         ASSERT(KeyValueInformation->DataLength <= dwDataLength);
  220.         RtlMoveMemory(lpData,
  221.             (PBYTE)KeyValueInformation + KeyValueInformation->DataOffset,
  222.             KeyValueInformation->DataLength);
  223.         if (KeyValueInformation->Type == REG_SZ ||
  224.             KeyValueInformation->Type ==REG_MULTI_SZ
  225.            ) {
  226.             if (KeyValueInformation->DataLength + sizeof(WCHAR) > dwDataLength) {
  227.                 KeyValueInformation->DataLength -= sizeof(WCHAR);
  228.             }
  229.             lpData[KeyValueInformation->DataLength++] = 0;
  230.             lpData[KeyValueInformation->DataLength] = 0;
  231.         }
  232.     }
  233.     LocalFree(KeyValueInformation);
  234.     return Status;
  235. }
  236. #endif
  238. LPWSTR
  239. TranslateConsoleTitle(
  240.     LPWSTR ConsoleTitle
  241.     )
  242. /*++
  244.     this routine translates path characters into '_' characters because
  245.     the NT registry apis do not allow the creation of keys with
  246.     names that contain path characters.  it allocates a buffer that
  247.     must be freed.
  249. --*/
  250. {
  251.     int ConsoleTitleLength, i;
  252.     LPWSTR TranslatedTitle;
  254.     ConsoleTitleLength = lstrlenW(ConsoleTitle) + 1;
  255.     TranslatedTitle = HeapAlloc(RtlProcessHeap(), 0,
  256.                                 ConsoleTitleLength * sizeof(WCHAR));
  257.     if (TranslatedTitle == NULL) {
  258.         return NULL;
  259.     }
  260.     for (i = 0; i < ConsoleTitleLength; i++) {
  261.         if (ConsoleTitle[i] == '\') {
  262.             TranslatedTitle[i] = (WCHAR)'_';
  263.         } else {
  264.             TranslatedTitle[i] = ConsoleTitle[i];
  265.         }
  266.     }
  267.     return TranslatedTitle;
  268. }
  271. NTSTATUS
  272. MyRegSetValue(
  273.     IN HANDLE hKey,
  274.     IN LPWSTR lpValueName,
  275.     IN DWORD dwType,
  276.     IN LPVOID lpData,
  277.     IN DWORD cbData
  278.     )
  279. {
  280.     UNICODE_STRING ValueName;
  282.     //
  283.     // Convert the subkey to a counted Unicode string.
  284.     //
  286.     RtlInitUnicodeString( &ValueName, lpValueName );
  288.     return NtSetValueKey(
  289.                     hKey,
  290.                     &ValueName,
  291.                     0,
  292.                     dwType,
  293.                     lpData,
  294.                     cbData
  295.                     );
  296. }
  299. NTSTATUS
  300. MyRegUpdateValue(
  301.     IN HANDLE hConsoleKey,
  302.     IN HANDLE hKey,
  303.     IN LPWSTR lpValueName,
  304.     IN DWORD dwType,
  305.     IN LPVOID lpData,
  306.     IN DWORD cbData
  307.     )
  308. {
  309.     NTSTATUS Status;
  310.     BYTE Data[MAX_PATH];
  312.     //
  313.     // If this is not the main console key but the value is the same,
  314.     // delete it. Otherwise, set it.
  315.     //
  317.     if (hConsoleKey != hKey) {
  318.         Status = MyRegQueryValue(hConsoleKey, lpValueName, sizeof(Data), Data);
  319.         if (NT_SUCCESS(Status)) {
  320.             if (RtlCompareMemory(lpData, Data, cbData) == cbData) {
  321.                 return MyRegDeleteKey(hKey, lpValueName);
  322.             }
  323.         }
  324.     }
  326.     return MyRegSetValue(hKey, lpValueName, dwType, lpData, cbData);
  327. }
  330. PCONSOLE_STATE_INFO
  331. InitRegistryValues(VOID)
  333. /*++
  335. Routine Description:
  337.     This routine allocates a state info structure and fill it in with
  338.     default values.
  340. Arguments:
  342.     none
  344. Return Value:
  346.     pStateInfo - pointer to structure to receive information
  348. --*/
  350. {
  351.     PCONSOLE_STATE_INFO pStateInfo;
  353.     pStateInfo = HeapAlloc(RtlProcessHeap(), 0, sizeof(CONSOLE_STATE_INFO));
  354.     if (pStateInfo == NULL) {
  355.         return NULL;
  356.     }
  358.     pStateInfo->Length = sizeof(CONSOLE_STATE_INFO);
  359.     pStateInfo->ScreenAttributes = 0x07;            // white on black
  360.     pStateInfo->PopupAttributes = 0xf5;             // purple on white
  361.     pStateInfo->InsertMode = FALSE;
  362.     pStateInfo->QuickEdit = FALSE;
  363.     pStateInfo->FullScreen = FALSE;
  364.     pStateInfo->ScreenBufferSize.X = 80;
  365.     pStateInfo->ScreenBufferSize.Y = 25;
  366.     pStateInfo->WindowSize.X = 80;
  367.     pStateInfo->WindowSize.Y = 25;
  368.     pStateInfo->WindowPosX = 0;
  369.     pStateInfo->WindowPosY = 0;
  370.     pStateInfo->AutoPosition = TRUE;
  371.     pStateInfo->FontSize.X = 0;
  372.     pStateInfo->FontSize.Y = 0;
  373.     pStateInfo->FontFamily = 0;
  374.     pStateInfo->FontWeight = 0;
  375.     pStateInfo->FaceName[0] = TEXT('');
  376.     pStateInfo->CursorSize = 25;
  377.     pStateInfo->HistoryBufferSize = 25;
  378.     pStateInfo->NumberOfHistoryBuffers = 4;
  379.     pStateInfo->HistoryNoDup = 0;
  380.     pStateInfo->ColorTable[ 0] = RGB(0,   0,   0   );
  381.     pStateInfo->ColorTable[ 1] = RGB(0,   0,   0x80);
  382.     pStateInfo->ColorTable[ 2] = RGB(0,   0x80,0   );
  383.     pStateInfo->ColorTable[ 3] = RGB(0,   0x80,0x80);
  384.     pStateInfo->ColorTable[ 4] = RGB(0x80,0,   0   );
  385.     pStateInfo->ColorTable[ 5] = RGB(0x80,0,   0x80);
  386.     pStateInfo->ColorTable[ 6] = RGB(0x80,0x80,0   );
  387.     pStateInfo->ColorTable[ 7] = RGB(0xC0,0xC0,0xC0);
  388.     pStateInfo->ColorTable[ 8] = RGB(0x80,0x80,0x80);
  389.     pStateInfo->ColorTable[ 9] = RGB(0,   0,   0xFF);
  390.     pStateInfo->ColorTable[10] = RGB(0,   0xFF,0   );
  391.     pStateInfo->ColorTable[11] = RGB(0,   0xFF,0xFF);
  392.     pStateInfo->ColorTable[12] = RGB(0xFF,0,   0   );
  393.     pStateInfo->ColorTable[13] = RGB(0xFF,0,   0xFF);
  394.     pStateInfo->ColorTable[14] = RGB(0xFF,0xFF,0   );
  395.     pStateInfo->ColorTable[15] = RGB(0xFF,0xFF,0xFF);
  396. #if defined(FE_SB)
  397.     pStateInfo->CodePage = OEMCP; // scotthsu
  398. #endif
  399.     pStateInfo->hWnd = NULL;
  400.     pStateInfo->ConsoleTitle[0] = TEXT('');
  402.     return pStateInfo;
  403. }
  406. DWORD
  407. GetRegistryValues(
  408.     PCONSOLE_STATE_INFO pStateInfo
  409.     )
  411. /*++
  413. Routine Description:
  415.     This routine reads in values from the registry and places them
  416.     in the supplied structure.
  418. Arguments:
  420.     pStateInfo - optional pointer to structure to receive information
  422. Return Value:
  424.     current page number
  426. --*/
  428. {
  429.     HANDLE hCurrentUserKey;
  430.     HANDLE hConsoleKey;
  431.     HANDLE hTitleKey;
  432.     NTSTATUS Status;
  433.     LPWSTR TranslatedTitle;
  434.     DWORD dwValue;
  435.     DWORD dwRet = 0;
  436.     DWORD i;
  437.     WCHAR awchBuffer[LF_FACESIZE];
  439.     //
  440.     // Open the current user registry key
  441.     //
  443.     Status = RtlOpenCurrentUser(MAXIMUM_ALLOWED, &hCurrentUserKey);
  444.     if (!NT_SUCCESS(Status)) {
  445.         return 0;
  446.     }
  448.     //
  449.     // Open the console registry key
  450.     //
  452.     Status = MyRegOpenKey(hCurrentUserKey,
  453.                           CONSOLE_REGISTRY_STRING,
  454.                           &hConsoleKey);
  455.     if (!NT_SUCCESS(Status)) {
  456.         NtClose(hCurrentUserKey);
  457.         return 0;
  458.     }
  460.     //
  461.     // If there is no structure to fill out, just get the current
  462.     // page and bail out.
  463.     //
  465.     if (pStateInfo == NULL) {
  466.         if (NT_SUCCESS(MyRegQueryValue(hConsoleKey,
  467.                        CONSOLE_REGISTRY_CURRENTPAGE,
  468.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  469.             dwRet = dwValue;
  470.         }
  471.         goto CloseKeys;
  472.     }
  474.     //
  475.     // Open the console title subkey, if there is one
  476.     //
  478.     if (pStateInfo->ConsoleTitle[0] != TEXT('')) {
  479.         TranslatedTitle = TranslateConsoleTitle(pStateInfo->ConsoleTitle);
  480.         if (TranslatedTitle == NULL) {
  481.             NtClose(hConsoleKey);
  482.             NtClose(hCurrentUserKey);
  483.             return 0;
  484.         }
  485.         Status = MyRegOpenKey(hConsoleKey,
  486.                               TranslatedTitle,
  487.                               &hTitleKey);
  488.         HeapFree(RtlProcessHeap(),0,TranslatedTitle);
  489.         if (!NT_SUCCESS(Status)) {
  490.             NtClose(hConsoleKey);
  491.             NtClose(hCurrentUserKey);
  492.             return 0;
  493.         }
  494.     } else {
  495.         hTitleKey = hConsoleKey;
  496.     }
  498.     //
  499.     // Initial screen fill
  500.     //
  502.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  503.                        CONSOLE_REGISTRY_FILLATTR,
  504.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  505.         pStateInfo->ScreenAttributes = (WORD)dwValue;
  506.     }
  508.     //
  509.     // Initial popup fill
  510.     //
  512.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  513.                        CONSOLE_REGISTRY_POPUPATTR,
  514.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  515.         pStateInfo->PopupAttributes = (WORD)dwValue;
  516.     }
  518.     //
  519.     // Initial color table
  520.     //
  522.     for (i = 0; i < 16; i++) {
  523.         wsprintf(awchBuffer, CONSOLE_REGISTRY_COLORTABLE, i);
  524.         if (NT_SUCCESS(MyRegQueryValue(hTitleKey, awchBuffer,
  525.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  526.             pStateInfo->ColorTable[i] = dwValue;
  527.         }
  528.     }
  530.     //
  531.     // Initial insert mode
  532.     //
  534.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  535.                        CONSOLE_REGISTRY_INSERTMODE,
  536.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  537.         pStateInfo->InsertMode = !!dwValue;
  538.     }
  540.     //
  541.     // Initial quick edit mode
  542.     //
  544.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  545.                        CONSOLE_REGISTRY_QUICKEDIT,
  546.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  547.         pStateInfo->QuickEdit = !!dwValue;
  548.     }
  550. #ifdef i386
  551.     //
  552.     // Initial full screen mode
  553.     //
  555.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  556.                        CONSOLE_REGISTRY_FULLSCR,
  557.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  558.         pStateInfo->FullScreen = !!dwValue;
  559.     }
  560. #endif
  561. #if defined(FE_SB) // scotthsu
  562.     //
  563.     // Initial code page
  564.     //
  566.     ASSERT(OEMCP != 0);
  567.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  568.                        CONSOLE_REGISTRY_CODEPAGE,
  569.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  570.         if (IsValidCodePage(dwValue)) {
  571.             pStateInfo->CodePage = (UINT) dwValue;
  572.         }
  573.     }
  574. #endif
  576.     //
  577.     // Initial screen buffer size
  578.     //
  580.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  581.                        CONSOLE_REGISTRY_BUFFERSIZE,
  582.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  583.         pStateInfo->ScreenBufferSize.X = LOWORD(dwValue);
  584.         pStateInfo->ScreenBufferSize.Y = HIWORD(dwValue);
  585.     }
  587.     //
  588.     // Initial window size
  589.     //
  591.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  592.                        CONSOLE_REGISTRY_WINDOWSIZE,
  593.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  594.         pStateInfo->WindowSize.X = LOWORD(dwValue);
  595.         pStateInfo->WindowSize.Y = HIWORD(dwValue);
  596.     }
  598.     //
  599.     // Initial window position
  600.     //
  602.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  603.                        CONSOLE_REGISTRY_WINDOWPOS,
  604.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  605.         pStateInfo->WindowPosX = (SHORT)LOWORD(dwValue);
  606.         pStateInfo->WindowPosY = (SHORT)HIWORD(dwValue);
  607.         pStateInfo->AutoPosition = FALSE;
  608.     }
  610.     //
  611.     // Initial font size
  612.     //
  614.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  615.                        CONSOLE_REGISTRY_FONTSIZE,
  616.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  617.         pStateInfo->FontSize.X = LOWORD(dwValue);
  618.         pStateInfo->FontSize.Y = HIWORD(dwValue);
  619.     }
  621.     //
  622.     // Initial font family
  623.     //
  625.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  626.                        CONSOLE_REGISTRY_FONTFAMILY,
  627.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  628.         pStateInfo->FontFamily = dwValue;
  629.     }
  631.     //
  632.     // Initial font weight
  633.     //
  635.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  636.                        CONSOLE_REGISTRY_FONTWEIGHT,
  637.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  638.         pStateInfo->FontWeight = dwValue;
  639.     }
  641.     //
  642.     // Initial font face name
  643.     //
  645.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  646.                        CONSOLE_REGISTRY_FACENAME,
  647.                        sizeof(awchBuffer), (PBYTE)awchBuffer))) {
  648.         RtlCopyMemory(pStateInfo->FaceName, awchBuffer, sizeof(awchBuffer));
  649.     }
  651.     //
  652.     // Initial cursor size
  653.     //
  655.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  656.                        CONSOLE_REGISTRY_CURSORSIZE,
  657.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  658.         pStateInfo->CursorSize = dwValue;
  659.     }
  661.     //
  662.     // Initial history buffer size
  663.     //
  665.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  666.                        CONSOLE_REGISTRY_HISTORYSIZE,
  667.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  668.         pStateInfo->HistoryBufferSize = dwValue;
  669.     }
  671.     //
  672.     // Initial number of history buffers
  673.     //
  675.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  676.                        CONSOLE_REGISTRY_HISTORYBUFS,
  677.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  678.         pStateInfo->NumberOfHistoryBuffers = dwValue;
  679.     }
  681.     //
  682.     // Initial history duplication mode
  683.     //
  685.     if (NT_SUCCESS(MyRegQueryValue(hTitleKey,
  686.                        CONSOLE_REGISTRY_HISTORYNODUP,
  687.                        sizeof(dwValue), (PBYTE)&dwValue))) {
  688.         pStateInfo->HistoryNoDup = dwValue;
  689.     }
  691.     //
  692.     // Close the registry keys
  693.     //
  695.     if (hTitleKey != hConsoleKey) {
  696.         NtClose(hTitleKey);
  697.     }
  699. CloseKeys:
  700.     NtClose(hConsoleKey);
  701.     NtClose(hCurrentUserKey);
  703.     return dwRet;
  704. }
  707. VOID
  708. SetRegistryValues(
  709.     PCONSOLE_STATE_INFO pStateInfo,
  710.     DWORD dwPage
  711.     )
  713. /*++
  715. Routine Description:
  717.     This routine writes values to the registry from the supplied
  718.     structure.
  720. Arguments:
  722.     pStateInfo - optional pointer to structure containing information
  723.     dwPage     - current page number
  725. Return Value:
  727.     none
  729. --*/
  731. {
  732.     HANDLE hCurrentUserKey;
  733.     HANDLE hConsoleKey;
  734.     HANDLE hTitleKey;
  735.     NTSTATUS Status;
  736.     LPWSTR TranslatedTitle;
  737.     DWORD dwValue;
  738.     DWORD i;
  739.     WCHAR awchBuffer[LF_FACESIZE];
  741.     //
  742.     // Open the current user registry key
  743.     //
  745.     Status = RtlOpenCurrentUser(MAXIMUM_ALLOWED, &hCurrentUserKey);
  746.     if (!NT_SUCCESS(Status)) {
  747.         return;
  748.     }
  750.     //
  751.     // Open the console registry key
  752.     //
  754.     Status = MyRegCreateKey(hCurrentUserKey,
  755.                             CONSOLE_REGISTRY_STRING,
  756.                             &hConsoleKey);
  757.     if (!NT_SUCCESS(Status)) {
  758.         NtClose(hCurrentUserKey);
  759.         return;
  760.     }
  762.     //
  763.     // Save the current page
  764.     //
  766.     MyRegSetValue(hConsoleKey,
  767.                   CONSOLE_REGISTRY_CURRENTPAGE,
  768.                   REG_DWORD, &dwPage, sizeof(dwPage));
  770.     //
  771.     // If we only want to save the current page, bail out
  772.     //
  774.     if (pStateInfo == NULL) {
  775.         goto CloseKeys;
  776.     }
  778.     //
  779.     // Open the console title subkey, if there is one
  780.     //
  782.     if (pStateInfo->ConsoleTitle[0] != TEXT('')) {
  783.         TranslatedTitle = TranslateConsoleTitle(pStateInfo->ConsoleTitle);
  784.         if (TranslatedTitle == NULL) {
  785.             NtClose(hConsoleKey);
  786.             NtClose(hCurrentUserKey);
  787.             return;
  788.         }
  789.         Status = MyRegCreateKey(hConsoleKey,
  790.                                 TranslatedTitle,
  791.                                 &hTitleKey);
  792.         HeapFree(RtlProcessHeap(),0,TranslatedTitle);
  793.         if (!NT_SUCCESS(Status)) {
  794.             NtClose(hConsoleKey);
  795.             NtClose(hCurrentUserKey);
  796.             return;
  797.         }
  798.     } else {
  799.         hTitleKey = hConsoleKey;
  800.     }
  802.     //
  803.     // Save screen and popup colors and color table
  804.     //
  806.     dwValue = pStateInfo->ScreenAttributes;
  807.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_FILLATTR,
  808.                      REG_DWORD, &dwValue, sizeof(dwValue));
  809.     dwValue = pStateInfo->PopupAttributes;
  810.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_POPUPATTR,
  811.                      REG_DWORD, &dwValue, sizeof(dwValue));
  812.     for (i = 0; i < 16; i++) {
  813.         dwValue = pStateInfo->ColorTable[i];
  814.         wsprintf(awchBuffer, CONSOLE_REGISTRY_COLORTABLE, i);
  815.         MyRegUpdateValue(hConsoleKey, hTitleKey, awchBuffer,
  816.                          REG_DWORD, &dwValue, sizeof(dwValue));
  817.     }
  819.     //
  820.     // Save insert, quickedit, and fullscreen mode settings
  821.     //
  823.     dwValue = pStateInfo->InsertMode;
  824.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_INSERTMODE,
  825.                      REG_DWORD, &dwValue, sizeof(dwValue));
  826.     dwValue = pStateInfo->QuickEdit;
  827.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_QUICKEDIT,
  828.                      REG_DWORD, &dwValue, sizeof(dwValue));
  829. #ifdef i386
  830.     dwValue = pStateInfo->FullScreen;
  831.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_FULLSCR,
  832.                      REG_DWORD, &dwValue, sizeof(dwValue));
  833. #endif
  834. #if defined(FE_SB) // scotthsu
  836.     ASSERT(OEMCP != 0);
  837.     if (gfFESystem) {
  838.         dwValue = (DWORD) pStateInfo->CodePage;
  839.         MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_CODEPAGE,
  840.                          REG_DWORD, &dwValue, sizeof(dwValue));
  841.     }
  842. #endif
  844.     //
  845.     // Save screen buffer size
  846.     //
  848.     dwValue = MAKELONG(pStateInfo->ScreenBufferSize.X,
  849.                        pStateInfo->ScreenBufferSize.Y);
  850.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_BUFFERSIZE,
  851.                      REG_DWORD, &dwValue, sizeof(dwValue));
  853.     //
  854.     // Save window size
  855.     //
  857.     dwValue = MAKELONG(pStateInfo->WindowSize.X,
  858.                        pStateInfo->WindowSize.Y);
  859.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_WINDOWSIZE,
  860.                      REG_DWORD, &dwValue, sizeof(dwValue));
  862.     //
  863.     // Save window position
  864.     //
  866.     if (pStateInfo->AutoPosition) {
  867.         MyRegDeleteKey(hTitleKey, CONSOLE_REGISTRY_WINDOWPOS);
  868.     } else {
  869.         dwValue = MAKELONG(pStateInfo->WindowPosX,
  870.                            pStateInfo->WindowPosY);
  871.         MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_WINDOWPOS,
  872.                          REG_DWORD, &dwValue, sizeof(dwValue));
  873.     }
  875.     //
  876.     // Save font size, family, weight, and face name
  877.     //
  879.     dwValue = MAKELONG(pStateInfo->FontSize.X,
  880.                        pStateInfo->FontSize.Y);
  881.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_FONTSIZE,
  882.                      REG_DWORD, &dwValue, sizeof(dwValue));
  883.     dwValue = pStateInfo->FontFamily;
  884.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_FONTFAMILY,
  885.                      REG_DWORD, &dwValue, sizeof(dwValue));
  886.     dwValue = pStateInfo->FontWeight;
  887.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_FONTWEIGHT,
  888.                      REG_DWORD, &dwValue, sizeof(dwValue));
  889.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_FACENAME,
  890.                      REG_SZ, pStateInfo->FaceName,
  891.                       (_tcslen(pStateInfo->FaceName) + 1) * sizeof(TCHAR));
  893.     //
  894.     // Save cursor size
  895.     //
  897.     dwValue = pStateInfo->CursorSize;
  898.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_CURSORSIZE,
  899.                      REG_DWORD, &dwValue, sizeof(dwValue));
  901.     //
  902.     // Save history buffer size and number
  903.     //
  905.     dwValue = pStateInfo->HistoryBufferSize;
  906.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_HISTORYSIZE,
  907.                      REG_DWORD, &dwValue, sizeof(dwValue));
  908.     dwValue = pStateInfo->NumberOfHistoryBuffers;
  909.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_HISTORYBUFS,
  910.                      REG_DWORD, &dwValue, sizeof(dwValue));
  911.     dwValue = pStateInfo->HistoryNoDup;
  912.     MyRegUpdateValue(hConsoleKey, hTitleKey, CONSOLE_REGISTRY_HISTORYNODUP,
  913.                      REG_DWORD, &dwValue, sizeof(dwValue));
  915.     //
  916.     // Close the registry keys
  917.     //
  919.     if (hTitleKey != hConsoleKey) {
  920.         NtClose(hTitleKey);
  921.     }
  923. CloseKeys:
  924.     NtClose(hConsoleKey);
  925.     NtClose(hCurrentUserKey);
  926. }