[SETUPLIB][USETUP] Use NT RTL String Safe functions instead of Win32-oriented ones...
[reactos.git] / base / setup / lib / settings.c
1 /*
2 * ReactOS kernel
3 * Copyright (C) 2004 ReactOS Team
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License along
16 * with this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
18 */
19 /* COPYRIGHT: See COPYING in the top level directory
20 * PROJECT: ReactOS text-mode setup
21 * FILE: base/setup/usetup/settings.c
22 * PURPOSE: Device settings support functions
23 * PROGRAMMERS: Colin Finck
24 */
25
26 /* INCLUDES *****************************************************************/
27
28 #include "precomp.h"
29 #include "genlist.h"
30 #include "infsupp.h"
31 #include "mui.h"
32 #include "registry.h"
33
34 #include "settings.h"
35
36 #define NDEBUG
37 #include <debug.h>
38
39 /* GLOBALS ******************************************************************/
40
41 static ULONG DefaultLanguageIndex = 0;
42
43 /* FUNCTIONS ****************************************************************/
44
45 static
46 BOOLEAN
47 IsAcpiComputer(VOID)
48 {
49 UNICODE_STRING MultiKeyPathU = RTL_CONSTANT_STRING(L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\MultifunctionAdapter");
50 UNICODE_STRING IdentifierU = RTL_CONSTANT_STRING(L"Identifier");
51 UNICODE_STRING AcpiBiosIdentifier = RTL_CONSTANT_STRING(L"ACPI BIOS");
52 OBJECT_ATTRIBUTES ObjectAttributes;
53 PKEY_BASIC_INFORMATION pDeviceInformation = NULL;
54 ULONG DeviceInfoLength = sizeof(KEY_BASIC_INFORMATION) + 50 * sizeof(WCHAR);
55 PKEY_VALUE_PARTIAL_INFORMATION pValueInformation = NULL;
56 ULONG ValueInfoLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) + 50 * sizeof(WCHAR);
57 ULONG RequiredSize;
58 ULONG IndexDevice = 0;
59 UNICODE_STRING DeviceName, ValueName;
60 HANDLE hDevicesKey = NULL;
61 HANDLE hDeviceKey = NULL;
62 NTSTATUS Status;
63 BOOLEAN ret = FALSE;
64
65 InitializeObjectAttributes(&ObjectAttributes,
66 &MultiKeyPathU,
67 OBJ_CASE_INSENSITIVE,
68 NULL,
69 NULL);
70 Status = NtOpenKey(&hDevicesKey,
71 KEY_ENUMERATE_SUB_KEYS,
72 &ObjectAttributes);
73 if (!NT_SUCCESS(Status))
74 {
75 DPRINT("NtOpenKey() failed with status 0x%08lx\n", Status);
76 goto cleanup;
77 }
78
79 pDeviceInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, DeviceInfoLength);
80 if (!pDeviceInformation)
81 {
82 DPRINT("RtlAllocateHeap() failed\n");
83 Status = STATUS_NO_MEMORY;
84 goto cleanup;
85 }
86
87 pValueInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, ValueInfoLength);
88 if (!pValueInformation)
89 {
90 DPRINT("RtlAllocateHeap() failed\n");
91 Status = STATUS_NO_MEMORY;
92 goto cleanup;
93 }
94
95 while (TRUE)
96 {
97 Status = NtEnumerateKey(hDevicesKey,
98 IndexDevice,
99 KeyBasicInformation,
100 pDeviceInformation,
101 DeviceInfoLength,
102 &RequiredSize);
103 if (Status == STATUS_NO_MORE_ENTRIES)
104 break;
105 else if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
106 {
107 RtlFreeHeap(RtlGetProcessHeap(), 0, pDeviceInformation);
108 DeviceInfoLength = RequiredSize;
109 pDeviceInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, DeviceInfoLength);
110 if (!pDeviceInformation)
111 {
112 DPRINT("RtlAllocateHeap() failed\n");
113 Status = STATUS_NO_MEMORY;
114 goto cleanup;
115 }
116 Status = NtEnumerateKey(hDevicesKey,
117 IndexDevice,
118 KeyBasicInformation,
119 pDeviceInformation,
120 DeviceInfoLength,
121 &RequiredSize);
122 }
123 if (!NT_SUCCESS(Status))
124 {
125 DPRINT("NtEnumerateKey() failed with status 0x%08lx\n", Status);
126 goto cleanup;
127 }
128 IndexDevice++;
129
130 /* Open device key */
131 DeviceName.Length = DeviceName.MaximumLength = pDeviceInformation->NameLength;
132 DeviceName.Buffer = pDeviceInformation->Name;
133 InitializeObjectAttributes(&ObjectAttributes,
134 &DeviceName,
135 OBJ_CASE_INSENSITIVE,
136 hDevicesKey,
137 NULL);
138 Status = NtOpenKey(&hDeviceKey,
139 KEY_QUERY_VALUE,
140 &ObjectAttributes);
141 if (!NT_SUCCESS(Status))
142 {
143 DPRINT("NtOpenKey() failed with status 0x%08lx\n", Status);
144 goto cleanup;
145 }
146
147 /* Read identifier */
148 Status = NtQueryValueKey(hDeviceKey,
149 &IdentifierU,
150 KeyValuePartialInformation,
151 pValueInformation,
152 ValueInfoLength,
153 &RequiredSize);
154 if (Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL)
155 {
156 RtlFreeHeap(RtlGetProcessHeap(), 0, pValueInformation);
157 ValueInfoLength = RequiredSize;
158 pValueInformation = RtlAllocateHeap(RtlGetProcessHeap(), 0, ValueInfoLength);
159 if (!pValueInformation)
160 {
161 DPRINT("RtlAllocateHeap() failed\n");
162 Status = STATUS_NO_MEMORY;
163 goto cleanup;
164 }
165 Status = NtQueryValueKey(hDeviceKey,
166 &IdentifierU,
167 KeyValuePartialInformation,
168 pValueInformation,
169 ValueInfoLength,
170 &RequiredSize);
171 }
172 if (!NT_SUCCESS(Status))
173 {
174 DPRINT("NtQueryValueKey() failed with status 0x%08lx\n", Status);
175 goto nextdevice;
176 }
177 else if (pValueInformation->Type != REG_SZ)
178 {
179 DPRINT("Wrong registry type: got 0x%lx, expected 0x%lx\n", pValueInformation->Type, REG_SZ);
180 goto nextdevice;
181 }
182
183 ValueName.Length = ValueName.MaximumLength = pValueInformation->DataLength;
184 ValueName.Buffer = (PWCHAR)pValueInformation->Data;
185 if (ValueName.Length >= sizeof(WCHAR) && ValueName.Buffer[ValueName.Length / sizeof(WCHAR) - 1] == UNICODE_NULL)
186 ValueName.Length -= sizeof(WCHAR);
187 if (RtlEqualUnicodeString(&ValueName, &AcpiBiosIdentifier, FALSE))
188 {
189 DPRINT("Found ACPI BIOS\n");
190 ret = TRUE;
191 goto cleanup;
192 }
193
194 nextdevice:
195 NtClose(hDeviceKey);
196 hDeviceKey = NULL;
197 }
198
199 cleanup:
200 if (pDeviceInformation)
201 RtlFreeHeap(RtlGetProcessHeap(), 0, pDeviceInformation);
202 if (pValueInformation)
203 RtlFreeHeap(RtlGetProcessHeap(), 0, pValueInformation);
204 if (hDevicesKey)
205 NtClose(hDevicesKey);
206 if (hDeviceKey)
207 NtClose(hDeviceKey);
208 return ret;
209 }
210
211 static
212 BOOLEAN
213 GetComputerIdentifier(
214 OUT PWSTR Identifier,
215 IN ULONG IdentifierLength)
216 {
217 OBJECT_ATTRIBUTES ObjectAttributes;
218 UNICODE_STRING KeyName;
219 LPCWSTR ComputerIdentifier;
220 HANDLE ProcessorsKey;
221 PKEY_FULL_INFORMATION pFullInfo;
222 ULONG Size, SizeNeeded;
223 NTSTATUS Status;
224
225 DPRINT("GetComputerIdentifier() called\n");
226
227 Size = sizeof(KEY_FULL_INFORMATION);
228 pFullInfo = (PKEY_FULL_INFORMATION)RtlAllocateHeap(RtlGetProcessHeap(), 0, Size);
229 if (!pFullInfo)
230 {
231 DPRINT("RtlAllocateHeap() failed\n");
232 return FALSE;
233 }
234
235 /* Open the processors key */
236 RtlInitUnicodeString(&KeyName,
237 L"\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System\\CentralProcessor");
238 InitializeObjectAttributes(&ObjectAttributes,
239 &KeyName,
240 OBJ_CASE_INSENSITIVE,
241 NULL,
242 NULL);
243
244 Status = NtOpenKey(&ProcessorsKey,
245 KEY_QUERY_VALUE,
246 &ObjectAttributes);
247 if (!NT_SUCCESS(Status))
248 {
249 DPRINT("NtOpenKey() failed (Status 0x%lx)\n", Status);
250 RtlFreeHeap(RtlGetProcessHeap(), 0, pFullInfo);
251 return FALSE;
252 }
253
254 /* Get number of subkeys */
255 Status = NtQueryKey(ProcessorsKey,
256 KeyFullInformation,
257 pFullInfo,
258 Size,
259 &Size);
260 NtClose(ProcessorsKey);
261 if (!NT_SUCCESS(Status) && Status != STATUS_BUFFER_OVERFLOW)
262 {
263 DPRINT("NtQueryKey() failed (Status 0x%lx)\n", Status);
264 RtlFreeHeap(RtlGetProcessHeap(), 0, pFullInfo);
265 return FALSE;
266 }
267
268 /* Find computer identifier */
269 if (pFullInfo->SubKeys == 0)
270 {
271 /* Something strange happened. No processor detected */
272 RtlFreeHeap(RtlGetProcessHeap(), 0, pFullInfo);
273 return FALSE;
274 }
275
276 if (IsAcpiComputer())
277 {
278 if (pFullInfo->SubKeys == 1)
279 {
280 /* Computer is mono-CPU */
281 ComputerIdentifier = L"ACPI UP";
282 }
283 else
284 {
285 /* Computer is multi-CPUs */
286 ComputerIdentifier = L"ACPI MP";
287 }
288 }
289 else
290 {
291 if (pFullInfo->SubKeys == 1)
292 {
293 /* Computer is mono-CPU */
294 ComputerIdentifier = L"PC UP";
295 }
296 else
297 {
298 /* Computer is multi-CPUs */
299 ComputerIdentifier = L"PC MP";
300 }
301 }
302
303 RtlFreeHeap(RtlGetProcessHeap(), 0, pFullInfo);
304
305 /* Copy computer identifier to return buffer */
306 SizeNeeded = (wcslen(ComputerIdentifier) + 1) * sizeof(WCHAR);
307 if (SizeNeeded > IdentifierLength)
308 return FALSE;
309
310 RtlCopyMemory(Identifier, ComputerIdentifier, SizeNeeded);
311
312 return TRUE;
313 }
314
315
316 /*
317 * Return values:
318 * 0x00: Failure, stop the enumeration;
319 * 0x01: Add the entry and continue the enumeration;
320 * 0x02: Skip the entry but continue the enumeration.
321 */
322 typedef UCHAR
323 (NTAPI *PPROCESS_ENTRY_ROUTINE)(
324 IN PWCHAR KeyName,
325 IN PWCHAR KeyValue,
326 OUT PWCHAR DisplayText,
327 IN SIZE_T DisplayTextSize,
328 OUT PVOID* UserData,
329 OUT PBOOLEAN Current,
330 IN PVOID Parameter OPTIONAL);
331
332 static LONG
333 AddEntriesFromInfSection(
334 IN OUT PGENERIC_LIST List,
335 IN HINF InfFile,
336 IN PCWSTR SectionName,
337 IN PINFCONTEXT pContext,
338 IN PPROCESS_ENTRY_ROUTINE ProcessEntry,
339 IN PVOID Parameter OPTIONAL)
340 {
341 LONG TotalCount = 0;
342 PWCHAR KeyName;
343 PWCHAR KeyValue;
344 PVOID UserData;
345 BOOLEAN Current;
346 UCHAR RetVal;
347 WCHAR DisplayText[128];
348
349 if (!SetupFindFirstLineW(InfFile, SectionName, NULL, pContext))
350 return -1;
351
352 do
353 {
354 /*
355 * NOTE: Do not use INF_GetData() as it expects INF entries of exactly
356 * two fields ("key = value"); however we expect to be able to deal with
357 * entries having more than two fields, the only requirement being that
358 * the second field (field number 1) contains the field description.
359 */
360 if (!INF_GetDataField(pContext, 0, &KeyName))
361 {
362 DPRINT("INF_GetDataField() failed\n");
363 return -1;
364 }
365
366 if (!INF_GetDataField(pContext, 1, &KeyValue))
367 {
368 DPRINT("INF_GetDataField() failed\n");
369 INF_FreeData(KeyName);
370 return -1;
371 }
372
373 UserData = NULL;
374 Current = FALSE;
375 RetVal = ProcessEntry(KeyName,
376 KeyValue,
377 DisplayText,
378 sizeof(DisplayText),
379 &UserData,
380 &Current,
381 Parameter);
382 INF_FreeData(KeyName);
383 INF_FreeData(KeyValue);
384
385 if (RetVal == 0)
386 {
387 DPRINT("ProcessEntry() failed\n");
388 return -1;
389 }
390 else if (RetVal == 1)
391 {
392 AppendGenericListEntry(List, DisplayText, UserData, Current);
393 ++TotalCount;
394 }
395 // else if (RetVal == 2), skip the entry.
396
397 } while (SetupFindNextLine(pContext, pContext));
398
399 return TotalCount;
400 }
401
402 static UCHAR
403 NTAPI
404 DefaultProcessEntry(
405 IN PWCHAR KeyName,
406 IN PWCHAR KeyValue,
407 OUT PWCHAR DisplayText,
408 IN SIZE_T DisplayTextSize,
409 OUT PVOID* UserData,
410 OUT PBOOLEAN Current,
411 IN PVOID Parameter OPTIONAL)
412 {
413 PWSTR CompareKey = (PWSTR)Parameter;
414
415 *UserData = RtlAllocateHeap(ProcessHeap, 0,
416 (wcslen(KeyName) + 1) * sizeof(WCHAR));
417 if (*UserData == NULL)
418 {
419 /* Failure, stop enumeration */
420 DPRINT1("RtlAllocateHeap() failed\n");
421 return 0;
422 }
423
424 wcscpy((PWCHAR)*UserData, KeyName);
425 RtlStringCbCopyW(DisplayText, DisplayTextSize, KeyValue);
426
427 *Current = (CompareKey ? !_wcsicmp(KeyName, CompareKey) : FALSE);
428
429 /* Add the entry */
430 return 1;
431 }
432
433
434 PGENERIC_LIST
435 CreateComputerTypeList(
436 IN HINF InfFile)
437 {
438 PGENERIC_LIST List;
439 INFCONTEXT Context;
440 PWCHAR KeyName;
441 PWCHAR KeyValue;
442 WCHAR ComputerIdentifier[128];
443 WCHAR ComputerKey[32];
444
445 /* Get the computer identification */
446 if (!GetComputerIdentifier(ComputerIdentifier, 128))
447 {
448 ComputerIdentifier[0] = 0;
449 }
450
451 DPRINT("Computer identifier: '%S'\n", ComputerIdentifier);
452
453 /* Search for matching device identifier */
454 if (!SetupFindFirstLineW(InfFile, L"Map.Computer", NULL, &Context))
455 {
456 /* FIXME: error message */
457 return NULL;
458 }
459
460 do
461 {
462 BOOLEAN FoundId;
463
464 if (!INF_GetDataField(&Context, 1, &KeyValue))
465 {
466 /* FIXME: Handle error! */
467 DPRINT("INF_GetDataField() failed\n");
468 return NULL;
469 }
470
471 DPRINT("KeyValue: %S\n", KeyValue);
472 FoundId = !!wcsstr(ComputerIdentifier, KeyValue);
473 INF_FreeData(KeyValue);
474
475 if (!FoundId)
476 continue;
477
478 if (!INF_GetDataField(&Context, 0, &KeyName))
479 {
480 /* FIXME: Handle error! */
481 DPRINT("INF_GetDataField() failed\n");
482 return NULL;
483 }
484
485 DPRINT("Computer key: %S\n", KeyName);
486 RtlStringCchCopyW(ComputerKey, ARRAYSIZE(ComputerKey), KeyName);
487 INF_FreeData(KeyName);
488 } while (SetupFindNextLine(&Context, &Context));
489
490 List = CreateGenericList();
491 if (List == NULL)
492 return NULL;
493
494 if (AddEntriesFromInfSection(List,
495 InfFile,
496 L"Computer",
497 &Context,
498 DefaultProcessEntry,
499 ComputerKey) == -1)
500 {
501 DestroyGenericList(List, TRUE);
502 return NULL;
503 }
504
505 return List;
506 }
507
508 static
509 BOOLEAN
510 GetDisplayIdentifier(
511 OUT PWSTR Identifier,
512 IN ULONG IdentifierLength)
513 {
514 OBJECT_ATTRIBUTES ObjectAttributes;
515 UNICODE_STRING KeyName;
516 WCHAR Buffer[32];
517 HANDLE BusKey;
518 HANDLE BusInstanceKey;
519 HANDLE ControllerKey;
520 HANDLE ControllerInstanceKey;
521 ULONG BusInstance;
522 ULONG ControllerInstance;
523 ULONG BufferLength;
524 ULONG ReturnedLength;
525 PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
526 NTSTATUS Status;
527
528 DPRINT("GetDisplayIdentifier() called\n");
529
530 /* Open the bus key */
531 RtlInitUnicodeString(&KeyName,
532 L"\\Registry\\Machine\\HARDWARE\\Description\\System\\MultifunctionAdapter");
533 InitializeObjectAttributes(&ObjectAttributes,
534 &KeyName,
535 OBJ_CASE_INSENSITIVE,
536 NULL,
537 NULL);
538
539 Status = NtOpenKey(&BusKey,
540 KEY_ENUMERATE_SUB_KEYS,
541 &ObjectAttributes);
542 if (!NT_SUCCESS(Status))
543 {
544 DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
545 return FALSE;
546 }
547
548 BusInstance = 0;
549 while (TRUE)
550 {
551 RtlStringCchPrintfW(Buffer, ARRAYSIZE(Buffer), L"%lu", BusInstance);
552 RtlInitUnicodeString(&KeyName, Buffer);
553 InitializeObjectAttributes(&ObjectAttributes,
554 &KeyName,
555 OBJ_CASE_INSENSITIVE,
556 BusKey,
557 NULL);
558
559 Status = NtOpenKey(&BusInstanceKey,
560 KEY_ENUMERATE_SUB_KEYS,
561 &ObjectAttributes);
562 if (!NT_SUCCESS(Status))
563 {
564 DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
565 NtClose(BusKey);
566 return FALSE;
567 }
568
569 /* Open the controller type key */
570 RtlInitUnicodeString(&KeyName, L"DisplayController");
571 InitializeObjectAttributes(&ObjectAttributes,
572 &KeyName,
573 OBJ_CASE_INSENSITIVE,
574 BusInstanceKey,
575 NULL);
576
577 Status = NtOpenKey(&ControllerKey,
578 KEY_ENUMERATE_SUB_KEYS,
579 &ObjectAttributes);
580 if (NT_SUCCESS(Status))
581 {
582 ControllerInstance = 0;
583
584 while (TRUE)
585 {
586 /* Open the pointer controller instance key */
587 RtlStringCchPrintfW(Buffer, ARRAYSIZE(Buffer), L"%lu", ControllerInstance);
588 RtlInitUnicodeString(&KeyName, Buffer);
589 InitializeObjectAttributes(&ObjectAttributes,
590 &KeyName,
591 OBJ_CASE_INSENSITIVE,
592 ControllerKey,
593 NULL);
594
595 Status = NtOpenKey(&ControllerInstanceKey,
596 KEY_QUERY_VALUE,
597 &ObjectAttributes);
598 if (!NT_SUCCESS(Status))
599 {
600 DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
601 NtClose(ControllerKey);
602 NtClose(BusInstanceKey);
603 NtClose(BusKey);
604 return FALSE;
605 }
606
607 /* Get controller identifier */
608 RtlInitUnicodeString(&KeyName, L"Identifier");
609
610 BufferLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
611 256 * sizeof(WCHAR);
612 ValueInfo = (KEY_VALUE_PARTIAL_INFORMATION*) RtlAllocateHeap(RtlGetProcessHeap(),
613 0,
614 BufferLength);
615 if (ValueInfo == NULL)
616 {
617 DPRINT("RtlAllocateHeap() failed\n");
618 NtClose(ControllerInstanceKey);
619 NtClose(ControllerKey);
620 NtClose(BusInstanceKey);
621 NtClose(BusKey);
622 return FALSE;
623 }
624
625 Status = NtQueryValueKey(ControllerInstanceKey,
626 &KeyName,
627 KeyValuePartialInformation,
628 ValueInfo,
629 BufferLength,
630 &ReturnedLength);
631 if (NT_SUCCESS(Status))
632 {
633 DPRINT("Identifier: %S\n", (PWSTR)ValueInfo->Data);
634
635 BufferLength = min(ValueInfo->DataLength / sizeof(WCHAR), IdentifierLength);
636 RtlCopyMemory(Identifier,
637 ValueInfo->Data,
638 BufferLength * sizeof(WCHAR));
639 Identifier[BufferLength] = 0;
640
641 RtlFreeHeap(RtlGetProcessHeap(),
642 0,
643 ValueInfo);
644
645 NtClose(ControllerInstanceKey);
646 NtClose(ControllerKey);
647 NtClose(BusInstanceKey);
648 NtClose(BusKey);
649 return TRUE;
650 }
651
652 NtClose(ControllerInstanceKey);
653
654 ControllerInstance++;
655 }
656
657 NtClose(ControllerKey);
658 }
659
660 NtClose(BusInstanceKey);
661
662 BusInstance++;
663 }
664
665 NtClose(BusKey);
666
667 return FALSE;
668 }
669
670 PGENERIC_LIST
671 CreateDisplayDriverList(
672 IN HINF InfFile)
673 {
674 PGENERIC_LIST List;
675 INFCONTEXT Context;
676 PWCHAR KeyName;
677 PWCHAR KeyValue;
678 WCHAR DisplayIdentifier[128];
679 WCHAR DisplayKey[32];
680
681 /* Get the display identification */
682 if (!GetDisplayIdentifier(DisplayIdentifier, 128))
683 {
684 DisplayIdentifier[0] = 0;
685 }
686
687 DPRINT("Display identifier: '%S'\n", DisplayIdentifier);
688
689 /* Search for matching device identifier */
690 if (!SetupFindFirstLineW(InfFile, L"Map.Display", NULL, &Context))
691 {
692 /* FIXME: error message */
693 return NULL;
694 }
695
696 do
697 {
698 BOOLEAN FoundId;
699
700 if (!INF_GetDataField(&Context, 1, &KeyValue))
701 {
702 /* FIXME: Handle error! */
703 DPRINT("INF_GetDataField() failed\n");
704 return NULL;
705 }
706
707 DPRINT("KeyValue: %S\n", KeyValue);
708 FoundId = !!wcsstr(DisplayIdentifier, KeyValue);
709 INF_FreeData(KeyValue);
710
711 if (!FoundId)
712 continue;
713
714 if (!INF_GetDataField(&Context, 0, &KeyName))
715 {
716 /* FIXME: Handle error! */
717 DPRINT("INF_GetDataField() failed\n");
718 return NULL;
719 }
720
721 DPRINT("Display key: %S\n", KeyName);
722 RtlStringCchCopyW(DisplayKey, ARRAYSIZE(DisplayKey), KeyName);
723 INF_FreeData(KeyName);
724 } while (SetupFindNextLine(&Context, &Context));
725
726 List = CreateGenericList();
727 if (List == NULL)
728 return NULL;
729
730 if (AddEntriesFromInfSection(List,
731 InfFile,
732 L"Display",
733 &Context,
734 DefaultProcessEntry,
735 DisplayKey) == -1)
736 {
737 DestroyGenericList(List, TRUE);
738 return NULL;
739 }
740
741 #if 0
742 AppendGenericListEntry(List, L"Other display driver", NULL, TRUE);
743 #endif
744
745 return List;
746 }
747
748
749 BOOLEAN
750 ProcessComputerFiles(
751 IN HINF InfFile,
752 IN PGENERIC_LIST List,
753 OUT PWSTR* AdditionalSectionName)
754 {
755 PGENERIC_LIST_ENTRY Entry;
756 static WCHAR SectionName[128];
757
758 DPRINT("ProcessComputerFiles() called\n");
759
760 Entry = GetCurrentListEntry(List);
761 if (Entry == NULL)
762 {
763 DPRINT("GetCurrentListEntry() failed\n");
764 return FALSE;
765 }
766
767 RtlStringCchPrintfW(SectionName, ARRAYSIZE(SectionName),
768 L"Files.%s", (PCWSTR)GetListEntryUserData(Entry));
769 *AdditionalSectionName = SectionName;
770
771 return TRUE;
772 }
773
774 BOOLEAN
775 ProcessDisplayRegistry(
776 IN HINF InfFile,
777 IN PGENERIC_LIST List)
778 {
779 NTSTATUS Status;
780 PGENERIC_LIST_ENTRY Entry;
781 INFCONTEXT Context;
782 PWCHAR Buffer;
783 PWCHAR ServiceName;
784 ULONG StartValue;
785 ULONG Width, Height, Bpp;
786 OBJECT_ATTRIBUTES ObjectAttributes;
787 UNICODE_STRING KeyName;
788 HANDLE KeyHandle;
789 WCHAR RegPath[255];
790
791 DPRINT("ProcessDisplayRegistry() called\n");
792
793 Entry = GetCurrentListEntry(List);
794 if (Entry == NULL)
795 {
796 DPRINT1("GetCurrentListEntry() failed\n");
797 return FALSE;
798 }
799
800 if (!SetupFindFirstLineW(InfFile, L"Display", (WCHAR*)GetListEntryUserData(Entry), &Context))
801 {
802 DPRINT1("SetupFindFirstLineW() failed\n");
803 return FALSE;
804 }
805
806 /* Enable the correct driver */
807 if (!INF_GetDataField(&Context, 3, &ServiceName))
808 {
809 DPRINT1("INF_GetDataField() failed\n");
810 return FALSE;
811 }
812
813 ASSERT(wcslen(ServiceName) < 10);
814 DPRINT1("Service name: '%S'\n", ServiceName);
815
816 RtlStringCchPrintfW(RegPath, ARRAYSIZE(RegPath),
817 L"System\\CurrentControlSet\\Services\\%s",
818 ServiceName);
819 RtlInitUnicodeString(&KeyName, RegPath);
820 InitializeObjectAttributes(&ObjectAttributes,
821 &KeyName,
822 OBJ_CASE_INSENSITIVE,
823 GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
824 NULL);
825 Status = NtOpenKey(&KeyHandle,
826 KEY_SET_VALUE,
827 &ObjectAttributes);
828 if (!NT_SUCCESS(Status))
829 {
830 DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
831 return FALSE;
832 }
833
834 StartValue = 1;
835 Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
836 L"Start",
837 REG_DWORD,
838 &StartValue,
839 sizeof(StartValue));
840 NtClose(KeyHandle);
841 if (!NT_SUCCESS(Status))
842 {
843 DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
844 return FALSE;
845 }
846
847 /* Set the resolution */
848
849 if (!INF_GetDataField(&Context, 4, &Buffer))
850 {
851 DPRINT1("INF_GetDataField() failed\n");
852 return FALSE;
853 }
854
855 RtlStringCchPrintfW(RegPath, ARRAYSIZE(RegPath),
856 L"System\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Services\\%s\\Device0",
857 ServiceName);
858 DPRINT1("RegPath: '%S'\n", RegPath);
859 RtlInitUnicodeString(&KeyName, RegPath);
860 InitializeObjectAttributes(&ObjectAttributes,
861 &KeyName,
862 OBJ_CASE_INSENSITIVE,
863 GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
864 NULL);
865 Status = NtOpenKey(&KeyHandle,
866 KEY_SET_VALUE,
867 &ObjectAttributes);
868 if (!NT_SUCCESS(Status))
869 {
870 DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
871 return FALSE;
872 }
873
874 Width = wcstoul(Buffer, NULL, 10);
875 Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
876 L"DefaultSettings.XResolution",
877 REG_DWORD,
878 &Width,
879 sizeof(Width));
880 if (!NT_SUCCESS(Status))
881 {
882 DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
883 NtClose(KeyHandle);
884 return FALSE;
885 }
886
887 if (!INF_GetDataField(&Context, 5, &Buffer))
888 {
889 DPRINT1("INF_GetDataField() failed\n");
890 NtClose(KeyHandle);
891 return FALSE;
892 }
893
894 Height = wcstoul(Buffer, 0, 0);
895 Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
896 L"DefaultSettings.YResolution",
897 REG_DWORD,
898 &Height,
899 sizeof(Height));
900 if (!NT_SUCCESS(Status))
901 {
902 DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
903 NtClose(KeyHandle);
904 return FALSE;
905 }
906
907 if (!INF_GetDataField(&Context, 6, &Buffer))
908 {
909 DPRINT1("INF_GetDataField() failed\n");
910 NtClose(KeyHandle);
911 return FALSE;
912 }
913
914 Bpp = wcstoul(Buffer, 0, 0);
915 Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
916 L"DefaultSettings.BitsPerPel",
917 REG_DWORD,
918 &Bpp,
919 sizeof(Bpp));
920 if (!NT_SUCCESS(Status))
921 {
922 DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
923 NtClose(KeyHandle);
924 return FALSE;
925 }
926
927 NtClose(KeyHandle);
928
929 DPRINT("ProcessDisplayRegistry() done\n");
930
931 return TRUE;
932 }
933
934 BOOLEAN
935 ProcessLocaleRegistry(
936 IN PGENERIC_LIST List)
937 {
938 PGENERIC_LIST_ENTRY Entry;
939 PWCHAR LanguageId;
940 OBJECT_ATTRIBUTES ObjectAttributes;
941 UNICODE_STRING KeyName;
942 UNICODE_STRING ValueName;
943
944 HANDLE KeyHandle;
945 NTSTATUS Status;
946
947 Entry = GetCurrentListEntry(List);
948 if (Entry == NULL)
949 return FALSE;
950
951 LanguageId = (PWCHAR)GetListEntryUserData(Entry);
952 if (LanguageId == NULL)
953 return FALSE;
954
955 DPRINT("LanguageId: %S\n", LanguageId);
956
957 /* Open the default users locale key */
958 RtlInitUnicodeString(&KeyName,
959 L".DEFAULT\\Control Panel\\International");
960
961 InitializeObjectAttributes(&ObjectAttributes,
962 &KeyName,
963 OBJ_CASE_INSENSITIVE,
964 GetRootKeyByPredefKey(HKEY_USERS, NULL),
965 NULL);
966
967 Status = NtOpenKey(&KeyHandle,
968 KEY_SET_VALUE,
969 &ObjectAttributes);
970 if (!NT_SUCCESS(Status))
971 {
972 DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
973 return FALSE;
974 }
975
976 /* Set default user locale */
977 RtlInitUnicodeString(&ValueName, L"Locale");
978 Status = NtSetValueKey(KeyHandle,
979 &ValueName,
980 0,
981 REG_SZ,
982 (PVOID)LanguageId,
983 (wcslen(LanguageId) + 1) * sizeof(WCHAR));
984 NtClose(KeyHandle);
985 if (!NT_SUCCESS(Status))
986 {
987 DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
988 return FALSE;
989 }
990
991 /* Skip first 4 zeroes */
992 if (wcslen(LanguageId) >= 4)
993 LanguageId += 4;
994
995 /* Open the NLS language key */
996 RtlInitUnicodeString(&KeyName,
997 L"SYSTEM\\CurrentControlSet\\Control\\NLS\\Language");
998
999 InitializeObjectAttributes(&ObjectAttributes,
1000 &KeyName,
1001 OBJ_CASE_INSENSITIVE,
1002 GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
1003 NULL);
1004
1005 Status = NtOpenKey(&KeyHandle,
1006 KEY_SET_VALUE,
1007 &ObjectAttributes);
1008 if (!NT_SUCCESS(Status))
1009 {
1010 DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
1011 return FALSE;
1012 }
1013
1014 /* Set default language */
1015 RtlInitUnicodeString(&ValueName, L"Default");
1016 Status = NtSetValueKey(KeyHandle,
1017 &ValueName,
1018 0,
1019 REG_SZ,
1020 (PVOID)LanguageId,
1021 (wcslen(LanguageId) + 1) * sizeof(WCHAR));
1022 if (!NT_SUCCESS(Status))
1023 {
1024 DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
1025 NtClose(KeyHandle);
1026 return FALSE;
1027 }
1028
1029 /* Set install language */
1030 RtlInitUnicodeString(&ValueName, L"InstallLanguage");
1031 Status = NtSetValueKey(KeyHandle,
1032 &ValueName,
1033 0,
1034 REG_SZ,
1035 (PVOID)LanguageId,
1036 (wcslen(LanguageId) + 1) * sizeof(WCHAR));
1037 NtClose(KeyHandle);
1038 if (!NT_SUCCESS(Status))
1039 {
1040 DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
1041 return FALSE;
1042 }
1043
1044 return TRUE;
1045 }
1046
1047
1048 PGENERIC_LIST
1049 CreateKeyboardDriverList(
1050 IN HINF InfFile)
1051 {
1052 PGENERIC_LIST List;
1053 INFCONTEXT Context;
1054
1055 List = CreateGenericList();
1056 if (List == NULL)
1057 return NULL;
1058
1059 if (AddEntriesFromInfSection(List,
1060 InfFile,
1061 L"Keyboard",
1062 &Context,
1063 DefaultProcessEntry,
1064 NULL) == -1)
1065 {
1066 DestroyGenericList(List, TRUE);
1067 return NULL;
1068 }
1069
1070 return List;
1071 }
1072
1073
1074 ULONG
1075 GetDefaultLanguageIndex(VOID)
1076 {
1077 return DefaultLanguageIndex;
1078 }
1079
1080 typedef struct _LANG_ENTRY_PARAM
1081 {
1082 ULONG uIndex;
1083 PWCHAR DefaultLanguage;
1084 } LANG_ENTRY_PARAM, *PLANG_ENTRY_PARAM;
1085
1086 static UCHAR
1087 NTAPI
1088 ProcessLangEntry(
1089 IN PWCHAR KeyName,
1090 IN PWCHAR KeyValue,
1091 OUT PWCHAR DisplayText,
1092 IN SIZE_T DisplayTextSize,
1093 OUT PVOID* UserData,
1094 OUT PBOOLEAN Current,
1095 IN PVOID Parameter OPTIONAL)
1096 {
1097 PLANG_ENTRY_PARAM LangEntryParam = (PLANG_ENTRY_PARAM)Parameter;
1098
1099 if (!IsLanguageAvailable(KeyName))
1100 {
1101 /* The specified language is unavailable, skip the entry */
1102 return 2;
1103 }
1104
1105 *UserData = RtlAllocateHeap(ProcessHeap, 0,
1106 (wcslen(KeyName) + 1) * sizeof(WCHAR));
1107 if (*UserData == NULL)
1108 {
1109 /* Failure, stop enumeration */
1110 DPRINT1("RtlAllocateHeap() failed\n");
1111 return 0;
1112 }
1113
1114 wcscpy((PWCHAR)*UserData, KeyName);
1115 RtlStringCbCopyW(DisplayText, DisplayTextSize, KeyValue);
1116
1117 *Current = FALSE;
1118
1119 if (!_wcsicmp(KeyName, LangEntryParam->DefaultLanguage))
1120 DefaultLanguageIndex = LangEntryParam->uIndex;
1121
1122 LangEntryParam->uIndex++;
1123
1124 /* Add the entry */
1125 return 1;
1126 }
1127
1128 PGENERIC_LIST
1129 CreateLanguageList(
1130 IN HINF InfFile,
1131 OUT PWSTR DefaultLanguage)
1132 {
1133 PGENERIC_LIST List;
1134 INFCONTEXT Context;
1135 PWCHAR KeyValue;
1136
1137 LANG_ENTRY_PARAM LangEntryParam;
1138
1139 LangEntryParam.uIndex = 0;
1140 LangEntryParam.DefaultLanguage = DefaultLanguage;
1141
1142 /* Get default language id */
1143 if (!SetupFindFirstLineW(InfFile, L"NLS", L"DefaultLanguage", &Context))
1144 return NULL;
1145
1146 if (!INF_GetData(&Context, NULL, &KeyValue))
1147 return NULL;
1148
1149 wcscpy(DefaultLanguage, KeyValue);
1150
1151 List = CreateGenericList();
1152 if (List == NULL)
1153 return NULL;
1154
1155 if (AddEntriesFromInfSection(List,
1156 InfFile,
1157 L"Language",
1158 &Context,
1159 ProcessLangEntry,
1160 &LangEntryParam) == -1)
1161 {
1162 DestroyGenericList(List, TRUE);
1163 return NULL;
1164 }
1165
1166 /* Only one language available, make it the default one */
1167 if (LangEntryParam.uIndex == 1)
1168 {
1169 DefaultLanguageIndex = 0;
1170 wcscpy(DefaultLanguage,
1171 (PWSTR)GetListEntryUserData(GetFirstListEntry(List)));
1172 }
1173
1174 return List;
1175 }
1176
1177
1178 PGENERIC_LIST
1179 CreateKeyboardLayoutList(
1180 IN HINF InfFile,
1181 IN PCWSTR LanguageId,
1182 OUT PWSTR DefaultKBLayout)
1183 {
1184 PGENERIC_LIST List;
1185 INFCONTEXT Context;
1186 PWCHAR KeyValue;
1187 const MUI_LAYOUTS* LayoutsList;
1188 ULONG uIndex = 0;
1189
1190 /* Get default layout id */
1191 if (!SetupFindFirstLineW(InfFile, L"NLS", L"DefaultLayout", &Context))
1192 return NULL;
1193
1194 if (!INF_GetData(&Context, NULL, &KeyValue))
1195 return NULL;
1196
1197 wcscpy(DefaultKBLayout, KeyValue);
1198
1199 List = CreateGenericList();
1200 if (List == NULL)
1201 return NULL;
1202
1203 LayoutsList = MUIGetLayoutsList(LanguageId);
1204
1205 do
1206 {
1207 // NOTE: See https://svn.reactos.org/svn/reactos?view=revision&revision=68354
1208 if (AddEntriesFromInfSection(List,
1209 InfFile,
1210 L"KeyboardLayout",
1211 &Context,
1212 DefaultProcessEntry,
1213 DefaultKBLayout) == -1)
1214 {
1215 DestroyGenericList(List, TRUE);
1216 return NULL;
1217 }
1218
1219 uIndex++;
1220
1221 } while (LayoutsList[uIndex].LangID != NULL);
1222
1223 /* Check whether some keyboard layouts have been found */
1224 /* FIXME: Handle this case */
1225 if (GetNumberOfListEntries(List) == 0)
1226 {
1227 DPRINT1("No keyboard layouts have been found\n");
1228 DestroyGenericList(List, TRUE);
1229 return NULL;
1230 }
1231
1232 return List;
1233 }
1234
1235
1236 BOOLEAN
1237 ProcessKeyboardLayoutRegistry(
1238 IN PGENERIC_LIST List,
1239 IN PCWSTR LanguageId)
1240 {
1241 PGENERIC_LIST_ENTRY Entry;
1242 PWCHAR LayoutId;
1243 const MUI_LAYOUTS* LayoutsList;
1244 MUI_LAYOUTS NewLayoutsList[20];
1245 ULONG uIndex;
1246 ULONG uOldPos = 0;
1247
1248 Entry = GetCurrentListEntry(List);
1249 if (Entry == NULL)
1250 return FALSE;
1251
1252 LayoutId = (PWCHAR)GetListEntryUserData(Entry);
1253 if (LayoutId == NULL)
1254 return FALSE;
1255
1256 LayoutsList = MUIGetLayoutsList(LanguageId);
1257
1258 if (_wcsicmp(LayoutsList[0].LayoutID, LayoutId) == 0)
1259 return TRUE;
1260
1261 for (uIndex = 1; LayoutsList[uIndex].LangID != NULL; uIndex++)
1262 {
1263 if (_wcsicmp(LayoutsList[uIndex].LayoutID, LayoutId) == 0)
1264 {
1265 uOldPos = uIndex;
1266 continue;
1267 }
1268
1269 NewLayoutsList[uIndex].LangID = LayoutsList[uIndex].LangID;
1270 NewLayoutsList[uIndex].LayoutID = LayoutsList[uIndex].LayoutID;
1271 }
1272
1273 NewLayoutsList[uIndex].LangID = NULL;
1274 NewLayoutsList[uIndex].LayoutID = NULL;
1275 NewLayoutsList[uOldPos].LangID = LayoutsList[0].LangID;
1276 NewLayoutsList[uOldPos].LayoutID = LayoutsList[0].LayoutID;
1277 NewLayoutsList[0].LangID = LayoutsList[uOldPos].LangID;
1278 NewLayoutsList[0].LayoutID = LayoutsList[uOldPos].LayoutID;
1279
1280 return AddKbLayoutsToRegistry(NewLayoutsList);
1281 }
1282
1283 #if 0
1284 BOOLEAN
1285 ProcessKeyboardLayoutFiles(
1286 IN PGENERIC_LIST List)
1287 {
1288 return TRUE;
1289 }
1290 #endif
1291
1292 BOOLEAN
1293 SetGeoID(
1294 IN PCWSTR Id)
1295 {
1296 NTSTATUS Status;
1297 OBJECT_ATTRIBUTES ObjectAttributes;
1298 UNICODE_STRING Name;
1299 HANDLE KeyHandle;
1300
1301 RtlInitUnicodeString(&Name,
1302 L".DEFAULT\\Control Panel\\International\\Geo");
1303 InitializeObjectAttributes(&ObjectAttributes,
1304 &Name,
1305 OBJ_CASE_INSENSITIVE,
1306 GetRootKeyByPredefKey(HKEY_USERS, NULL),
1307 NULL);
1308 Status = NtOpenKey(&KeyHandle,
1309 KEY_SET_VALUE,
1310 &ObjectAttributes);
1311 if (!NT_SUCCESS(Status))
1312 {
1313 DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
1314 return FALSE;
1315 }
1316
1317 RtlInitUnicodeString(&Name, L"Nation");
1318 Status = NtSetValueKey(KeyHandle,
1319 &Name,
1320 0,
1321 REG_SZ,
1322 (PVOID)Id,
1323 (wcslen(Id) + 1) * sizeof(WCHAR));
1324 NtClose(KeyHandle);
1325 if (!NT_SUCCESS(Status))
1326 {
1327 DPRINT1("NtSetValueKey() failed (Status = %lx)\n", Status);
1328 return FALSE;
1329 }
1330
1331 return TRUE;
1332 }
1333
1334
1335 BOOLEAN
1336 SetDefaultPagefile(
1337 IN WCHAR Drive)
1338 {
1339 NTSTATUS Status;
1340 HANDLE KeyHandle;
1341 OBJECT_ATTRIBUTES ObjectAttributes;
1342 UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management");
1343 UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"PagingFiles");
1344 WCHAR ValueBuffer[] = L"?:\\pagefile.sys 0 0\0";
1345
1346 InitializeObjectAttributes(&ObjectAttributes,
1347 &KeyName,
1348 OBJ_CASE_INSENSITIVE,
1349 GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
1350 NULL);
1351 Status = NtOpenKey(&KeyHandle,
1352 KEY_ALL_ACCESS,
1353 &ObjectAttributes);
1354 if (!NT_SUCCESS(Status))
1355 return FALSE;
1356
1357 ValueBuffer[0] = Drive;
1358
1359 NtSetValueKey(KeyHandle,
1360 &ValueName,
1361 0,
1362 REG_MULTI_SZ,
1363 (PVOID)&ValueBuffer,
1364 sizeof(ValueBuffer));
1365
1366 NtClose(KeyHandle);
1367 return TRUE;
1368 }
1369
1370 /* EOF */