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 PCWSTR KeyName,
 325     IN PCWSTR KeyValue,
 326     OUT PVOID* UserData,
 327     OUT PBOOLEAN Current,
 328     IN PVOID Parameter OPTIONAL);
 329
 330 static LONG
 331 AddEntriesFromInfSection(
 332     IN OUT PGENERIC_LIST List,
 333     IN HINF InfFile,
 334     IN PCWSTR SectionName,
 335     IN PINFCONTEXT pContext,
 336     IN PPROCESS_ENTRY_ROUTINE ProcessEntry,
 337     IN PVOID Parameter OPTIONAL)
 338 {
 339     LONG TotalCount = 0;
 340     PCWSTR KeyName;
 341     PCWSTR KeyValue;
 342     PVOID UserData;
 343     BOOLEAN Current;
 344     UCHAR RetVal;
 345
 346     if (!SpInfFindFirstLine(InfFile, SectionName, NULL, pContext))
 347         return -1;
 348
 349     do
 350     {
 351         /*
 352          * NOTE: Do not use INF_GetData() as it expects INF entries of exactly
 353          * two fields ("key = value"); however we expect to be able to deal with
 354          * entries having more than two fields, the only requirement being that
 355          * the second field (field number 1) contains the field description.
 356          */
 357         if (!INF_GetDataField(pContext, 0, &KeyName))
 358         {
 359             DPRINT("INF_GetDataField() failed\n");
 360             return -1;
 361         }
 362
 363         if (!INF_GetDataField(pContext, 1, &KeyValue))
 364         {
 365             DPRINT("INF_GetDataField() failed\n");
 366             INF_FreeData(KeyName);
 367             return -1;
 368         }
 369
 370         UserData = NULL;
 371         Current  = FALSE;
 372         RetVal = ProcessEntry(KeyName,
 373                               KeyValue,
 374                               &UserData,
 375                               &Current,
 376                               Parameter);
 377         INF_FreeData(KeyName);
 378         INF_FreeData(KeyValue);
 379
 380         if (RetVal == 0)
 381         {
 382             DPRINT("ProcessEntry() failed\n");
 383             return -1;
 384         }
 385         else if (RetVal == 1)
 386         {
 387             AppendGenericListEntry(List, UserData, Current);
 388             ++TotalCount;
 389         }
 390         // else if (RetVal == 2), skip the entry.
 391
 392     } while (SpInfFindNextLine(pContext, pContext));
 393
 394     return TotalCount;
 395 }
 396
 397 static UCHAR
 398 NTAPI
 399 DefaultProcessEntry(
 400     IN PCWSTR KeyName,
 401     IN PCWSTR KeyValue,
 402     OUT PVOID* UserData,
 403     OUT PBOOLEAN Current,
 404     IN PVOID Parameter OPTIONAL)
 405 {
 406     PWSTR CompareKey = (PWSTR)Parameter;
 407
 408     PGENENTRY GenEntry;
 409     SIZE_T IdSize, ValueSize;
 410
 411     IdSize    = (wcslen(KeyName)  + 1) * sizeof(WCHAR);
 412     ValueSize = (wcslen(KeyValue) + 1) * sizeof(WCHAR);
 413
 414     GenEntry = RtlAllocateHeap(ProcessHeap, 0,
 415                                sizeof(*GenEntry) + IdSize + ValueSize);
 416     if (GenEntry == NULL)
 417     {
 418         /* Failure, stop enumeration */
 419         DPRINT1("RtlAllocateHeap() failed\n");
 420         return 0;
 421     }
 422
 423     GenEntry->Id    = (PCWSTR)((ULONG_PTR)GenEntry + sizeof(*GenEntry));
 424     GenEntry->Value = (PCWSTR)((ULONG_PTR)GenEntry + sizeof(*GenEntry) + IdSize);
 425     RtlStringCbCopyW((PWSTR)GenEntry->Id, IdSize, KeyName);
 426     RtlStringCbCopyW((PWSTR)GenEntry->Value, ValueSize, KeyValue);
 427
 428     *UserData = GenEntry;
 429     *Current  = (CompareKey ? !_wcsicmp(KeyName, CompareKey) : FALSE);
 430
 431     /* Add the entry */
 432     return 1;
 433 }
 434
 435
 436 PGENERIC_LIST
 437 CreateComputerTypeList(
 438     IN HINF InfFile)
 439 {
 440     PGENERIC_LIST List;
 441     INFCONTEXT Context;
 442     PCWSTR KeyName;
 443     PCWSTR KeyValue;
 444     WCHAR ComputerIdentifier[128];
 445     WCHAR ComputerKey[32];
 446
 447     /* Get the computer identification */
 448     if (!GetComputerIdentifier(ComputerIdentifier, 128))
 449     {
 450         ComputerIdentifier[0] = 0;
 451     }
 452
 453     DPRINT("Computer identifier: '%S'\n", ComputerIdentifier);
 454
 455     /* Search for matching device identifier */
 456     if (!SpInfFindFirstLine(InfFile, L"Map.Computer", NULL, &Context))
 457     {
 458         /* FIXME: error message */
 459         return NULL;
 460     }
 461
 462     do
 463     {
 464         BOOLEAN FoundId;
 465
 466         if (!INF_GetDataField(&Context, 1, &KeyValue))
 467         {
 468             /* FIXME: Handle error! */
 469             DPRINT("INF_GetDataField() failed\n");
 470             return NULL;
 471         }
 472
 473         DPRINT("KeyValue: %S\n", KeyValue);
 474         FoundId = !!wcsstr(ComputerIdentifier, KeyValue);
 475         INF_FreeData(KeyValue);
 476
 477         if (!FoundId)
 478             continue;
 479
 480         if (!INF_GetDataField(&Context, 0, &KeyName))
 481         {
 482             /* FIXME: Handle error! */
 483             DPRINT("INF_GetDataField() failed\n");
 484             return NULL;
 485         }
 486
 487         DPRINT("Computer key: %S\n", KeyName);
 488         RtlStringCchCopyW(ComputerKey, ARRAYSIZE(ComputerKey), KeyName);
 489         INF_FreeData(KeyName);
 490     } while (SpInfFindNextLine(&Context, &Context));
 491
 492     List = CreateGenericList();
 493     if (List == NULL)
 494         return NULL;
 495
 496     if (AddEntriesFromInfSection(List,
 497                                  InfFile,
 498                                  L"Computer",
 499                                  &Context,
 500                                  DefaultProcessEntry,
 501                                  ComputerKey) == -1)
 502     {
 503         DestroyGenericList(List, TRUE);
 504         return NULL;
 505     }
 506
 507     return List;
 508 }
 509
 510 static
 511 BOOLEAN
 512 GetDisplayIdentifier(
 513     OUT PWSTR Identifier,
 514     IN ULONG IdentifierLength)
 515 {
 516     OBJECT_ATTRIBUTES ObjectAttributes;
 517     UNICODE_STRING KeyName;
 518     WCHAR Buffer[32];
 519     HANDLE BusKey;
 520     HANDLE BusInstanceKey;
 521     HANDLE ControllerKey;
 522     HANDLE ControllerInstanceKey;
 523     ULONG BusInstance;
 524     ULONG ControllerInstance;
 525     ULONG BufferLength;
 526     ULONG ReturnedLength;
 527     PKEY_VALUE_PARTIAL_INFORMATION ValueInfo;
 528     NTSTATUS Status;
 529
 530     DPRINT("GetDisplayIdentifier() called\n");
 531
 532     /* Open the bus key */
 533     RtlInitUnicodeString(&KeyName,
 534                          L"\\Registry\\Machine\\HARDWARE\\Description\\System\\MultifunctionAdapter");
 535     InitializeObjectAttributes(&ObjectAttributes,
 536                                &KeyName,
 537                                OBJ_CASE_INSENSITIVE,
 538                                NULL,
 539                                NULL);
 540
 541     Status = NtOpenKey(&BusKey,
 542                        KEY_ENUMERATE_SUB_KEYS,
 543                        &ObjectAttributes);
 544     if (!NT_SUCCESS(Status))
 545     {
 546         DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
 547         return FALSE;
 548     }
 549
 550     BusInstance = 0;
 551     while (TRUE)
 552     {
 553         RtlStringCchPrintfW(Buffer, ARRAYSIZE(Buffer), L"%lu", BusInstance);
 554         RtlInitUnicodeString(&KeyName, Buffer);
 555         InitializeObjectAttributes(&ObjectAttributes,
 556                                    &KeyName,
 557                                    OBJ_CASE_INSENSITIVE,
 558                                    BusKey,
 559                                    NULL);
 560
 561         Status = NtOpenKey(&BusInstanceKey,
 562                            KEY_ENUMERATE_SUB_KEYS,
 563                            &ObjectAttributes);
 564         if (!NT_SUCCESS(Status))
 565         {
 566             DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
 567             NtClose(BusKey);
 568             return FALSE;
 569         }
 570
 571         /* Open the controller type key */
 572         RtlInitUnicodeString(&KeyName, L"DisplayController");
 573         InitializeObjectAttributes(&ObjectAttributes,
 574                                    &KeyName,
 575                                    OBJ_CASE_INSENSITIVE,
 576                                    BusInstanceKey,
 577                                    NULL);
 578
 579         Status = NtOpenKey(&ControllerKey,
 580                            KEY_ENUMERATE_SUB_KEYS,
 581                            &ObjectAttributes);
 582         if (NT_SUCCESS(Status))
 583         {
 584             ControllerInstance = 0;
 585
 586             while (TRUE)
 587             {
 588                 /* Open the pointer controller instance key */
 589                 RtlStringCchPrintfW(Buffer, ARRAYSIZE(Buffer), L"%lu", ControllerInstance);
 590                 RtlInitUnicodeString(&KeyName, Buffer);
 591                 InitializeObjectAttributes(&ObjectAttributes,
 592                                            &KeyName,
 593                                            OBJ_CASE_INSENSITIVE,
 594                                            ControllerKey,
 595                                            NULL);
 596
 597                 Status = NtOpenKey(&ControllerInstanceKey,
 598                                    KEY_QUERY_VALUE,
 599                                    &ObjectAttributes);
 600                 if (!NT_SUCCESS(Status))
 601                 {
 602                     DPRINT("NtOpenKey() failed (Status %lx)\n", Status);
 603                     NtClose(ControllerKey);
 604                     NtClose(BusInstanceKey);
 605                     NtClose(BusKey);
 606                     return FALSE;
 607                 }
 608
 609                 /* Get controller identifier */
 610                 RtlInitUnicodeString(&KeyName, L"Identifier");
 611
 612                 BufferLength = sizeof(KEY_VALUE_PARTIAL_INFORMATION) +
 613                                256 * sizeof(WCHAR);
 614                 ValueInfo = (KEY_VALUE_PARTIAL_INFORMATION*) RtlAllocateHeap(RtlGetProcessHeap(),
 615                                                                              0,
 616                                                                              BufferLength);
 617                 if (ValueInfo == NULL)
 618                 {
 619                     DPRINT("RtlAllocateHeap() failed\n");
 620                     NtClose(ControllerInstanceKey);
 621                     NtClose(ControllerKey);
 622                     NtClose(BusInstanceKey);
 623                     NtClose(BusKey);
 624                     return FALSE;
 625                 }
 626
 627                 Status = NtQueryValueKey(ControllerInstanceKey,
 628                                          &KeyName,
 629                                          KeyValuePartialInformation,
 630                                          ValueInfo,
 631                                          BufferLength,
 632                                          &ReturnedLength);
 633                 if (NT_SUCCESS(Status))
 634                 {
 635                     DPRINT("Identifier: %S\n", (PWSTR)ValueInfo->Data);
 636
 637                     BufferLength = min(ValueInfo->DataLength / sizeof(WCHAR), IdentifierLength);
 638                     RtlCopyMemory(Identifier,
 639                                   ValueInfo->Data,
 640                                   BufferLength * sizeof(WCHAR));
 641                     Identifier[BufferLength] = 0;
 642
 643                     RtlFreeHeap(RtlGetProcessHeap(),
 644                                 0,
 645                                 ValueInfo);
 646
 647                     NtClose(ControllerInstanceKey);
 648                     NtClose(ControllerKey);
 649                     NtClose(BusInstanceKey);
 650                     NtClose(BusKey);
 651                     return TRUE;
 652                 }
 653
 654                 NtClose(ControllerInstanceKey);
 655
 656                 ControllerInstance++;
 657             }
 658
 659             NtClose(ControllerKey);
 660         }
 661
 662         NtClose(BusInstanceKey);
 663
 664         BusInstance++;
 665     }
 666
 667     NtClose(BusKey);
 668
 669     return FALSE;
 670 }
 671
 672 PGENERIC_LIST
 673 CreateDisplayDriverList(
 674     IN HINF InfFile)
 675 {
 676     PGENERIC_LIST List;
 677     INFCONTEXT Context;
 678     PCWSTR KeyName;
 679     PCWSTR KeyValue;
 680     WCHAR DisplayIdentifier[128];
 681     WCHAR DisplayKey[32];
 682
 683     /* Get the display identification */
 684     if (!GetDisplayIdentifier(DisplayIdentifier, 128))
 685     {
 686         DisplayIdentifier[0] = 0;
 687     }
 688
 689     DPRINT("Display identifier: '%S'\n", DisplayIdentifier);
 690
 691     /* Search for matching device identifier */
 692     if (!SpInfFindFirstLine(InfFile, L"Map.Display", NULL, &Context))
 693     {
 694         /* FIXME: error message */
 695         return NULL;
 696     }
 697
 698     do
 699     {
 700         BOOLEAN FoundId;
 701
 702         if (!INF_GetDataField(&Context, 1, &KeyValue))
 703         {
 704             /* FIXME: Handle error! */
 705             DPRINT("INF_GetDataField() failed\n");
 706             return NULL;
 707         }
 708
 709         DPRINT("KeyValue: %S\n", KeyValue);
 710         FoundId = !!wcsstr(DisplayIdentifier, KeyValue);
 711         INF_FreeData(KeyValue);
 712
 713         if (!FoundId)
 714             continue;
 715
 716         if (!INF_GetDataField(&Context, 0, &KeyName))
 717         {
 718             /* FIXME: Handle error! */
 719             DPRINT("INF_GetDataField() failed\n");
 720             return NULL;
 721         }
 722
 723         DPRINT("Display key: %S\n", KeyName);
 724         RtlStringCchCopyW(DisplayKey, ARRAYSIZE(DisplayKey), KeyName);
 725         INF_FreeData(KeyName);
 726     } while (SpInfFindNextLine(&Context, &Context));
 727
 728     List = CreateGenericList();
 729     if (List == NULL)
 730         return NULL;
 731
 732     if (AddEntriesFromInfSection(List,
 733                                  InfFile,
 734                                  L"Display",
 735                                  &Context,
 736                                  DefaultProcessEntry,
 737                                  DisplayKey) == -1)
 738     {
 739         DestroyGenericList(List, TRUE);
 740         return NULL;
 741     }
 742
 743 #if 0
 744     AppendGenericListEntry(List, L"Other display driver", NULL, TRUE);
 745 #endif
 746
 747     return List;
 748 }
 749
 750
 751 BOOLEAN
 752 ProcessComputerFiles(
 753     IN HINF InfFile,
 754     IN PGENERIC_LIST List,
 755     OUT PWSTR* AdditionalSectionName)
 756 {
 757     PGENERIC_LIST_ENTRY Entry;
 758     static WCHAR SectionName[128];
 759
 760     DPRINT("ProcessComputerFiles() called\n");
 761
 762     Entry = GetCurrentListEntry(List);
 763     if (Entry == NULL)
 764         return FALSE;
 765
 766     RtlStringCchPrintfW(SectionName, ARRAYSIZE(SectionName),
 767                         L"Files.%s", ((PGENENTRY)GetListEntryData(Entry))->Id);
 768     *AdditionalSectionName = SectionName;
 769
 770     return TRUE;
 771 }
 772
 773 BOOLEAN
 774 ProcessDisplayRegistry(
 775     IN HINF InfFile,
 776     IN PGENERIC_LIST List)
 777 {
 778     NTSTATUS Status;
 779     PGENERIC_LIST_ENTRY Entry;
 780     INFCONTEXT Context;
 781     PCWSTR Buffer;
 782     PCWSTR ServiceName;
 783     ULONG StartValue;
 784     ULONG Width, Height, Bpp;
 785     OBJECT_ATTRIBUTES ObjectAttributes;
 786     UNICODE_STRING KeyName;
 787     HANDLE KeyHandle;
 788     WCHAR RegPath[255];
 789
 790     DPRINT("ProcessDisplayRegistry() called\n");
 791
 792     Entry = GetCurrentListEntry(List);
 793     if (Entry == NULL)
 794         return FALSE;
 795
 796     if (!SpInfFindFirstLine(InfFile, L"Display",
 797                             ((PGENENTRY)GetListEntryData(Entry))->Id,
 798                             &Context))
 799     {
 800         DPRINT1("SpInfFindFirstLine() failed\n");
 801         return FALSE;
 802     }
 803
 804     /* Enable the correct driver */
 805     if (!INF_GetDataField(&Context, 3, &ServiceName))
 806     {
 807         DPRINT1("INF_GetDataField() failed\n");
 808         return FALSE;
 809     }
 810
 811     ASSERT(wcslen(ServiceName) < 10);
 812     DPRINT("Service name: '%S'\n", ServiceName);
 813
 814     RtlStringCchPrintfW(RegPath, ARRAYSIZE(RegPath),
 815                         L"System\\CurrentControlSet\\Services\\%s",
 816                         ServiceName);
 817     RtlInitUnicodeString(&KeyName, RegPath);
 818     InitializeObjectAttributes(&ObjectAttributes,
 819                                &KeyName,
 820                                OBJ_CASE_INSENSITIVE,
 821                                GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
 822                                NULL);
 823     Status = NtOpenKey(&KeyHandle,
 824                        KEY_SET_VALUE,
 825                        &ObjectAttributes);
 826     if (!NT_SUCCESS(Status))
 827     {
 828         DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
 829         return FALSE;
 830     }
 831
 832     StartValue = 1;
 833     Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
 834                                    L"Start",
 835                                    REG_DWORD,
 836                                    &StartValue,
 837                                    sizeof(StartValue));
 838     NtClose(KeyHandle);
 839     if (!NT_SUCCESS(Status))
 840     {
 841         DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
 842         return FALSE;
 843     }
 844
 845     /* Set the resolution */
 846
 847     if (!INF_GetDataField(&Context, 4, &Buffer))
 848     {
 849         DPRINT1("INF_GetDataField() failed\n");
 850         return FALSE;
 851     }
 852
 853     RtlStringCchPrintfW(RegPath, ARRAYSIZE(RegPath),
 854                         L"System\\CurrentControlSet\\Hardware Profiles\\Current\\System\\CurrentControlSet\\Services\\%s\\Device0",
 855                         ServiceName);
 856     DPRINT("RegPath: '%S'\n", RegPath);
 857     RtlInitUnicodeString(&KeyName, RegPath);
 858     InitializeObjectAttributes(&ObjectAttributes,
 859                                &KeyName,
 860                                OBJ_CASE_INSENSITIVE,
 861                                GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
 862                                NULL);
 863     Status = NtOpenKey(&KeyHandle,
 864                        KEY_SET_VALUE,
 865                        &ObjectAttributes);
 866     if (!NT_SUCCESS(Status))
 867     {
 868         DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
 869         return FALSE;
 870     }
 871
 872     Width = wcstoul(Buffer, NULL, 10);
 873     Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
 874                                    L"DefaultSettings.XResolution",
 875                                    REG_DWORD,
 876                                    &Width,
 877                                    sizeof(Width));
 878     if (!NT_SUCCESS(Status))
 879     {
 880         DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
 881         NtClose(KeyHandle);
 882         return FALSE;
 883     }
 884
 885     if (!INF_GetDataField(&Context, 5, &Buffer))
 886     {
 887         DPRINT1("INF_GetDataField() failed\n");
 888         NtClose(KeyHandle);
 889         return FALSE;
 890     }
 891
 892     Height = wcstoul(Buffer, 0, 0);
 893     Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
 894                                    L"DefaultSettings.YResolution",
 895                                    REG_DWORD,
 896                                    &Height,
 897                                    sizeof(Height));
 898     if (!NT_SUCCESS(Status))
 899     {
 900         DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
 901         NtClose(KeyHandle);
 902         return FALSE;
 903     }
 904
 905     if (!INF_GetDataField(&Context, 6, &Buffer))
 906     {
 907         DPRINT1("INF_GetDataField() failed\n");
 908         NtClose(KeyHandle);
 909         return FALSE;
 910     }
 911
 912     Bpp = wcstoul(Buffer, 0, 0);
 913     Status = RtlWriteRegistryValue(RTL_REGISTRY_HANDLE, KeyHandle,
 914                                    L"DefaultSettings.BitsPerPel",
 915                                    REG_DWORD,
 916                                    &Bpp,
 917                                    sizeof(Bpp));
 918     if (!NT_SUCCESS(Status))
 919     {
 920         DPRINT1("RtlWriteRegistryValue() failed (Status %lx)\n", Status);
 921         NtClose(KeyHandle);
 922         return FALSE;
 923     }
 924
 925     NtClose(KeyHandle);
 926
 927     DPRINT("ProcessDisplayRegistry() done\n");
 928
 929     return TRUE;
 930 }
 931
 932 BOOLEAN
 933 ProcessLocaleRegistry(
 934     IN PGENERIC_LIST List)
 935 {
 936     PGENERIC_LIST_ENTRY Entry;
 937     PCWSTR LanguageId;
 938     OBJECT_ATTRIBUTES ObjectAttributes;
 939     UNICODE_STRING KeyName;
 940     UNICODE_STRING ValueName;
 941
 942     HANDLE KeyHandle;
 943     NTSTATUS Status;
 944
 945     Entry = GetCurrentListEntry(List);
 946     if (Entry == NULL)
 947         return FALSE;
 948
 949     LanguageId = ((PGENENTRY)GetListEntryData(Entry))->Id;
 950     if (LanguageId == NULL)
 951         return FALSE;
 952
 953     DPRINT("LanguageId: %S\n", LanguageId);
 954
 955     /* Open the default users locale key */
 956     RtlInitUnicodeString(&KeyName,
 957                          L".DEFAULT\\Control Panel\\International");
 958
 959     InitializeObjectAttributes(&ObjectAttributes,
 960                                &KeyName,
 961                                OBJ_CASE_INSENSITIVE,
 962                                GetRootKeyByPredefKey(HKEY_USERS, NULL),
 963                                NULL);
 964
 965     Status = NtOpenKey(&KeyHandle,
 966                        KEY_SET_VALUE,
 967                        &ObjectAttributes);
 968     if (!NT_SUCCESS(Status))
 969     {
 970         DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
 971         return FALSE;
 972     }
 973
 974     /* Set default user locale */
 975     RtlInitUnicodeString(&ValueName, L"Locale");
 976     Status = NtSetValueKey(KeyHandle,
 977                            &ValueName,
 978                            0,
 979                            REG_SZ,
 980                            (PVOID)LanguageId,
 981                            (wcslen(LanguageId) + 1) * sizeof(WCHAR));
 982     NtClose(KeyHandle);
 983     if (!NT_SUCCESS(Status))
 984     {
 985         DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
 986         return FALSE;
 987     }
 988
 989     /* Skip first 4 zeroes */
 990     if (wcslen(LanguageId) >= 4)
 991         LanguageId += 4;
 992
 993     /* Open the NLS language key */
 994     RtlInitUnicodeString(&KeyName,
 995                          L"SYSTEM\\CurrentControlSet\\Control\\NLS\\Language");
 996
 997     InitializeObjectAttributes(&ObjectAttributes,
 998                                &KeyName,
 999                                OBJ_CASE_INSENSITIVE,
1000                                GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
1001                                NULL);
1002
1003     Status = NtOpenKey(&KeyHandle,
1004                        KEY_SET_VALUE,
1005                        &ObjectAttributes);
1006     if (!NT_SUCCESS(Status))
1007     {
1008         DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
1009         return FALSE;
1010     }
1011
1012     /* Set default language */
1013     RtlInitUnicodeString(&ValueName, L"Default");
1014     Status = NtSetValueKey(KeyHandle,
1015                            &ValueName,
1016                            0,
1017                            REG_SZ,
1018                            (PVOID)LanguageId,
1019                            (wcslen(LanguageId) + 1) * sizeof(WCHAR));
1020     if (!NT_SUCCESS(Status))
1021     {
1022         DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
1023         NtClose(KeyHandle);
1024         return FALSE;
1025     }
1026
1027     /* Set install language */
1028     RtlInitUnicodeString(&ValueName, L"InstallLanguage");
1029     Status = NtSetValueKey(KeyHandle,
1030                            &ValueName,
1031                            0,
1032                            REG_SZ,
1033                            (PVOID)LanguageId,
1034                            (wcslen(LanguageId) + 1) * sizeof(WCHAR));
1035     NtClose(KeyHandle);
1036     if (!NT_SUCCESS(Status))
1037     {
1038         DPRINT1("NtSetValueKey() failed (Status %lx)\n", Status);
1039         return FALSE;
1040     }
1041
1042     return TRUE;
1043 }
1044
1045
1046 PGENERIC_LIST
1047 CreateKeyboardDriverList(
1048     IN HINF InfFile)
1049 {
1050     PGENERIC_LIST List;
1051     INFCONTEXT Context;
1052
1053     List = CreateGenericList();
1054     if (List == NULL)
1055         return NULL;
1056
1057     if (AddEntriesFromInfSection(List,
1058                                  InfFile,
1059                                  L"Keyboard",
1060                                  &Context,
1061                                  DefaultProcessEntry,
1062                                  NULL) == -1)
1063     {
1064         DestroyGenericList(List, TRUE);
1065         return NULL;
1066     }
1067
1068     return List;
1069 }
1070
1071
1072 ULONG
1073 GetDefaultLanguageIndex(VOID)
1074 {
1075     return DefaultLanguageIndex;
1076 }
1077
1078 typedef struct _LANG_ENTRY_PARAM
1079 {
1080     ULONG uIndex;
1081     PWCHAR DefaultLanguage;
1082 } LANG_ENTRY_PARAM, *PLANG_ENTRY_PARAM;
1083
1084 static UCHAR
1085 NTAPI
1086 ProcessLangEntry(
1087     IN PCWSTR KeyName,
1088     IN PCWSTR KeyValue,
1089     OUT PVOID* UserData,
1090     OUT PBOOLEAN Current,
1091     IN PVOID Parameter OPTIONAL)
1092 {
1093     PLANG_ENTRY_PARAM LangEntryParam = (PLANG_ENTRY_PARAM)Parameter;
1094
1095     PGENENTRY GenEntry;
1096     SIZE_T IdSize, ValueSize;
1097
1098     if (!IsLanguageAvailable(KeyName))
1099     {
1100         /* The specified language is unavailable, skip the entry */
1101         return 2;
1102     }
1103
1104     IdSize    = (wcslen(KeyName)  + 1) * sizeof(WCHAR);
1105     ValueSize = (wcslen(KeyValue) + 1) * sizeof(WCHAR);
1106
1107     GenEntry = RtlAllocateHeap(ProcessHeap, 0,
1108                                sizeof(*GenEntry) + IdSize + ValueSize);
1109     if (GenEntry == NULL)
1110     {
1111         /* Failure, stop enumeration */
1112         DPRINT1("RtlAllocateHeap() failed\n");
1113         return 0;
1114     }
1115
1116     GenEntry->Id    = (PCWSTR)((ULONG_PTR)GenEntry + sizeof(*GenEntry));
1117     GenEntry->Value = (PCWSTR)((ULONG_PTR)GenEntry + sizeof(*GenEntry) + IdSize);
1118     RtlStringCbCopyW((PWSTR)GenEntry->Id, IdSize, KeyName);
1119     RtlStringCbCopyW((PWSTR)GenEntry->Value, ValueSize, KeyValue);
1120
1121     *UserData = GenEntry;
1122     *Current  = FALSE;
1123
1124     if (!_wcsicmp(KeyName, LangEntryParam->DefaultLanguage))
1125         DefaultLanguageIndex = LangEntryParam->uIndex;
1126
1127     LangEntryParam->uIndex++;
1128
1129     /* Add the entry */
1130     return 1;
1131 }
1132
1133 PGENERIC_LIST
1134 CreateLanguageList(
1135     IN HINF InfFile,
1136     OUT PWSTR DefaultLanguage)
1137 {
1138     PGENERIC_LIST List;
1139     INFCONTEXT Context;
1140     PCWSTR KeyValue;
1141
1142     LANG_ENTRY_PARAM LangEntryParam;
1143
1144     LangEntryParam.uIndex = 0;
1145     LangEntryParam.DefaultLanguage = DefaultLanguage;
1146
1147     /* Get default language id */
1148     if (!SpInfFindFirstLine(InfFile, L"NLS", L"DefaultLanguage", &Context))
1149         return NULL;
1150
1151     if (!INF_GetData(&Context, NULL, &KeyValue))
1152         return NULL;
1153
1154     wcscpy(DefaultLanguage, KeyValue);
1155
1156     List = CreateGenericList();
1157     if (List == NULL)
1158         return NULL;
1159
1160     if (AddEntriesFromInfSection(List,
1161                                  InfFile,
1162                                  L"Language",
1163                                  &Context,
1164                                  ProcessLangEntry,
1165                                  &LangEntryParam) == -1)
1166     {
1167         DestroyGenericList(List, TRUE);
1168         return NULL;
1169     }
1170
1171     /* Only one language available, make it the default one */
1172     if (LangEntryParam.uIndex == 1)
1173     {
1174         DefaultLanguageIndex = 0;
1175         wcscpy(DefaultLanguage,
1176                ((PGENENTRY)GetListEntryData(GetFirstListEntry(List)))->Id);
1177     }
1178
1179     return List;
1180 }
1181
1182
1183 PGENERIC_LIST
1184 CreateKeyboardLayoutList(
1185     IN HINF InfFile,
1186     IN PCWSTR LanguageId,
1187     OUT PWSTR DefaultKBLayout)
1188 {
1189     PGENERIC_LIST List;
1190     INFCONTEXT Context;
1191     PCWSTR KeyValue;
1192     const MUI_LAYOUTS* LayoutsList;
1193     ULONG uIndex = 0;
1194
1195     /* Get default layout id */
1196     if (!SpInfFindFirstLine(InfFile, L"NLS", L"DefaultLayout", &Context))
1197         return NULL;
1198
1199     if (!INF_GetData(&Context, NULL, &KeyValue))
1200         return NULL;
1201
1202     wcscpy(DefaultKBLayout, KeyValue);
1203
1204     List = CreateGenericList();
1205     if (List == NULL)
1206         return NULL;
1207
1208     LayoutsList = MUIGetLayoutsList(LanguageId);
1209
1210     do
1211     {
1212         // NOTE: See https://svn.reactos.org/svn/reactos?view=revision&revision=68354
1213         if (AddEntriesFromInfSection(List,
1214                                      InfFile,
1215                                      L"KeyboardLayout",
1216                                      &Context,
1217                                      DefaultProcessEntry,
1218                                      DefaultKBLayout) == -1)
1219         {
1220             DestroyGenericList(List, TRUE);
1221             return NULL;
1222         }
1223
1224         uIndex++;
1225
1226     } while (LayoutsList[uIndex].LangID != NULL);
1227
1228     /* Check whether some keyboard layouts have been found */
1229     /* FIXME: Handle this case */
1230     if (GetNumberOfListEntries(List) == 0)
1231     {
1232         DPRINT1("No keyboard layouts have been found\n");
1233         DestroyGenericList(List, TRUE);
1234         return NULL;
1235     }
1236
1237     return List;
1238 }
1239
1240
1241 BOOLEAN
1242 ProcessKeyboardLayoutRegistry(
1243     IN PGENERIC_LIST List,
1244     IN PCWSTR LanguageId)
1245 {
1246     PGENERIC_LIST_ENTRY Entry;
1247     PCWSTR LayoutId;
1248     const MUI_LAYOUTS* LayoutsList;
1249     MUI_LAYOUTS NewLayoutsList[20];
1250     ULONG uIndex;
1251     ULONG uOldPos = 0;
1252
1253     Entry = GetCurrentListEntry(List);
1254     if (Entry == NULL)
1255         return FALSE;
1256
1257     LayoutId = ((PGENENTRY)GetListEntryData(Entry))->Id;
1258     if (LayoutId == NULL)
1259         return FALSE;
1260
1261     LayoutsList = MUIGetLayoutsList(LanguageId);
1262
1263     if (_wcsicmp(LayoutsList[0].LayoutID, LayoutId) == 0)
1264         return TRUE;
1265
1266     for (uIndex = 1; LayoutsList[uIndex].LangID != NULL; uIndex++)
1267     {
1268         if (_wcsicmp(LayoutsList[uIndex].LayoutID, LayoutId) == 0)
1269         {
1270             uOldPos = uIndex;
1271             continue;
1272         }
1273
1274         NewLayoutsList[uIndex].LangID   = LayoutsList[uIndex].LangID;
1275         NewLayoutsList[uIndex].LayoutID = LayoutsList[uIndex].LayoutID;
1276     }
1277
1278     NewLayoutsList[uIndex].LangID    = NULL;
1279     NewLayoutsList[uIndex].LayoutID  = NULL;
1280     NewLayoutsList[uOldPos].LangID   = LayoutsList[0].LangID;
1281     NewLayoutsList[uOldPos].LayoutID = LayoutsList[0].LayoutID;
1282     NewLayoutsList[0].LangID         = LayoutsList[uOldPos].LangID;
1283     NewLayoutsList[0].LayoutID       = LayoutsList[uOldPos].LayoutID;
1284
1285     return AddKbLayoutsToRegistry(NewLayoutsList);
1286 }
1287
1288 #if 0
1289 BOOLEAN
1290 ProcessKeyboardLayoutFiles(
1291     IN PGENERIC_LIST List)
1292 {
1293     return TRUE;
1294 }
1295 #endif
1296
1297 BOOLEAN
1298 SetGeoID(
1299     IN PCWSTR Id)
1300 {
1301     NTSTATUS Status;
1302     OBJECT_ATTRIBUTES ObjectAttributes;
1303     UNICODE_STRING Name;
1304     HANDLE KeyHandle;
1305
1306     RtlInitUnicodeString(&Name,
1307                          L".DEFAULT\\Control Panel\\International\\Geo");
1308     InitializeObjectAttributes(&ObjectAttributes,
1309                                &Name,
1310                                OBJ_CASE_INSENSITIVE,
1311                                GetRootKeyByPredefKey(HKEY_USERS, NULL),
1312                                NULL);
1313     Status =  NtOpenKey(&KeyHandle,
1314                         KEY_SET_VALUE,
1315                         &ObjectAttributes);
1316     if (!NT_SUCCESS(Status))
1317     {
1318         DPRINT1("NtOpenKey() failed (Status %lx)\n", Status);
1319         return FALSE;
1320     }
1321
1322     RtlInitUnicodeString(&Name, L"Nation");
1323     Status = NtSetValueKey(KeyHandle,
1324                            &Name,
1325                            0,
1326                            REG_SZ,
1327                            (PVOID)Id,
1328                            (wcslen(Id) + 1) * sizeof(WCHAR));
1329     NtClose(KeyHandle);
1330     if (!NT_SUCCESS(Status))
1331     {
1332         DPRINT1("NtSetValueKey() failed (Status = %lx)\n", Status);
1333         return FALSE;
1334     }
1335
1336     return TRUE;
1337 }
1338
1339
1340 BOOLEAN
1341 SetDefaultPagefile(
1342     IN WCHAR Drive)
1343 {
1344     NTSTATUS Status;
1345     HANDLE KeyHandle;
1346     OBJECT_ATTRIBUTES ObjectAttributes;
1347     UNICODE_STRING KeyName = RTL_CONSTANT_STRING(L"SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Memory Management");
1348     UNICODE_STRING ValueName = RTL_CONSTANT_STRING(L"PagingFiles");
1349     WCHAR ValueBuffer[] = L"?:\\pagefile.sys 0 0\0";
1350
1351     InitializeObjectAttributes(&ObjectAttributes,
1352                                &KeyName,
1353                                OBJ_CASE_INSENSITIVE,
1354                                GetRootKeyByPredefKey(HKEY_LOCAL_MACHINE, NULL),
1355                                NULL);
1356     Status = NtOpenKey(&KeyHandle,
1357                        KEY_ALL_ACCESS,
1358                        &ObjectAttributes);
1359     if (!NT_SUCCESS(Status))
1360         return FALSE;
1361
1362     ValueBuffer[0] = Drive;
1363
1364     NtSetValueKey(KeyHandle,
1365                   &ValueName,
1366                   0,
1367                   REG_MULTI_SZ,
1368                   (PVOID)&ValueBuffer,
1369                   sizeof(ValueBuffer));
1370
1371     NtClose(KeyHandle);
1372     return TRUE;
1373 }
1374
1375 /* EOF */