boot/freeldr/freeldr/ntldr/wlregistry.c

   1 /*
   2  * PROJECT:         EFI Windows Loader
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * FILE:            boot/freeldr/freeldr/windows/wlregistry.c
   5  * PURPOSE:         Registry support functions
   6  * PROGRAMMERS:     Aleksey Bragin (aleksey@reactos.org)
   7  */
   8
   9 /* INCLUDES ***************************************************************/
  10
  11 #include <freeldr.h>
  12 #include "winldr.h"
  13 #include "registry.h"
  14
  15 #include <debug.h>
  16 DBG_DEFAULT_CHANNEL(WINDOWS);
  17
  18 // The only global var here, used to mark mem pages as NLS in WinLdrSetupMemoryLayout()
  19 ULONG TotalNLSSize = 0;
  20
  21 static BOOLEAN
  22 WinLdrGetNLSNames(LPSTR AnsiName,
  23                   LPSTR OemName,
  24                   LPSTR LangName);
  25
  26 static VOID
  27 WinLdrScanRegistry(IN OUT PLIST_ENTRY BootDriverListHead,
  28                    IN LPCSTR DirectoryPath);
  29
  30
  31 /* FUNCTIONS **************************************************************/
  32
  33 static BOOLEAN
  34 WinLdrLoadSystemHive(
  35     IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
  36     IN PCSTR DirectoryPath,
  37     IN PCSTR HiveName)
  38 {
  39     ULONG FileId;
  40     CHAR FullHiveName[MAX_PATH];
  41     ARC_STATUS Status;
  42     FILEINFORMATION FileInfo;
  43     ULONG HiveFileSize;
  44     ULONG_PTR HiveDataPhysical;
  45     PVOID HiveDataVirtual;
  46     ULONG BytesRead;
  47     PCWSTR FsService;
  48
  49     /* Concatenate path and filename to get the full name */
  50     strcpy(FullHiveName, DirectoryPath);
  51     strcat(FullHiveName, HiveName);
  52
  53     Status = ArcOpen(FullHiveName, OpenReadOnly, &FileId);
  54     if (Status != ESUCCESS)
  55     {
  56         WARN("Error while opening '%s', Status: %u\n", FullHiveName, Status);
  57         UiMessageBox("Opening hive file failed!");
  58         return FALSE;
  59     }
  60
  61     /* Get the file length */
  62     Status = ArcGetFileInformation(FileId, &FileInfo);
  63     if (Status != ESUCCESS)
  64     {
  65         ArcClose(FileId);
  66         UiMessageBox("Hive file has 0 size!");
  67         return FALSE;
  68     }
  69     HiveFileSize = FileInfo.EndingAddress.LowPart;
  70
  71     /* Round up the size to page boundary and alloc memory */
  72     HiveDataPhysical = (ULONG_PTR)MmAllocateMemoryWithType(
  73         MM_SIZE_TO_PAGES(HiveFileSize + MM_PAGE_SIZE - 1) << MM_PAGE_SHIFT,
  74         LoaderRegistryData);
  75
  76     if (HiveDataPhysical == 0)
  77     {
  78         ArcClose(FileId);
  79         UiMessageBox("Unable to alloc memory for a hive!");
  80         return FALSE;
  81     }
  82
  83     /* Convert address to virtual */
  84     HiveDataVirtual = PaToVa((PVOID)HiveDataPhysical);
  85
  86     /* Fill LoaderBlock's entries */
  87     LoaderBlock->RegistryLength = HiveFileSize;
  88     LoaderBlock->RegistryBase = HiveDataVirtual;
  89
  90     /* Finally read from file to the memory */
  91     Status = ArcRead(FileId, (PVOID)HiveDataPhysical, HiveFileSize, &BytesRead);
  92     if (Status != ESUCCESS)
  93     {
  94         ArcClose(FileId);
  95         WARN("Error while reading '%s', Status: %u\n", FullHiveName, Status);
  96         UiMessageBox("Unable to read from hive file!");
  97         return FALSE;
  98     }
  99
 100     /* Add boot filesystem driver to the list */
 101     FsService = FsGetServiceName(FileId);
 102     if (FsService)
 103     {
 104         BOOLEAN Success;
 105         TRACE("  Adding filesystem service %S\n", FsService);
 106         Success = WinLdrAddDriverToList(&LoaderBlock->BootDriverListHead,
 107                                         L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\",
 108                                         NULL,
 109                                         (LPWSTR)FsService);
 110         if (!Success)
 111             TRACE(" Failed to add filesystem service\n");
 112     }
 113     else
 114     {
 115         TRACE("  No required filesystem service\n");
 116     }
 117
 118     ArcClose(FileId);
 119     return TRUE;
 120 }
 121
 122 BOOLEAN
 123 WinLdrInitSystemHive(
 124     IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
 125     IN PCSTR SystemRoot,
 126     IN BOOLEAN Setup)
 127 {
 128     CHAR SearchPath[1024];
 129     PCSTR HiveName;
 130     BOOLEAN Success;
 131
 132     if (Setup)
 133     {
 134         strcpy(SearchPath, SystemRoot);
 135         HiveName = "SETUPREG.HIV";
 136     }
 137     else
 138     {
 139         // There is a simple logic here: try to load usual hive (system), if it
 140         // fails, then give system.alt a try, and finally try a system.sav
 141
 142         // FIXME: For now we only try system
 143         strcpy(SearchPath, SystemRoot);
 144         strcat(SearchPath, "system32\\config\\");
 145         HiveName = "SYSTEM";
 146     }
 147
 148     TRACE("WinLdrInitSystemHive: loading hive %s%s\n", SearchPath, HiveName);
 149     Success = WinLdrLoadSystemHive(LoaderBlock, SearchPath, HiveName);
 150
 151     /* Fail if failed... */
 152     if (!Success)
 153         return FALSE;
 154
 155     /* Import what was loaded */
 156     Success = RegImportBinaryHive(VaToPa(LoaderBlock->RegistryBase), LoaderBlock->RegistryLength);
 157     if (!Success)
 158     {
 159         UiMessageBox("Importing binary hive failed!");
 160         return FALSE;
 161     }
 162
 163     /* Initialize the 'CurrentControlSet' link */
 164     if (RegInitCurrentControlSet(FALSE) != ERROR_SUCCESS)
 165     {
 166         UiMessageBox("Initializing CurrentControlSet link failed!");
 167         return FALSE;
 168     }
 169
 170     return TRUE;
 171 }
 172
 173 BOOLEAN WinLdrScanSystemHive(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
 174                              IN LPCSTR DirectoryPath)
 175 {
 176     CHAR SearchPath[1024];
 177     CHAR AnsiName[256], OemName[256], LangName[256];
 178     BOOLEAN Success;
 179
 180     /* Scan registry and prepare boot drivers list */
 181     WinLdrScanRegistry(&LoaderBlock->BootDriverListHead, DirectoryPath);
 182
 183     /* Get names of NLS files */
 184     Success = WinLdrGetNLSNames(AnsiName, OemName, LangName);
 185     if (!Success)
 186     {
 187         UiMessageBox("Getting NLS names from registry failed!");
 188         return FALSE;
 189     }
 190
 191     TRACE("NLS data %s %s %s\n", AnsiName, OemName, LangName);
 192
 193     /* Load NLS data */
 194     strcpy(SearchPath, DirectoryPath);
 195     strcat(SearchPath, "system32\\");
 196     Success = WinLdrLoadNLSData(LoaderBlock, SearchPath, AnsiName, OemName, LangName);
 197     TRACE("NLS data loading %s\n", Success ? "successful" : "failed");
 198
 199     /* TODO: Load OEM HAL font */
 200     // In HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Nls\CodePage,
 201     // REG_SZ value "OEMHAL"
 202
 203     return TRUE;
 204 }
 205
 206
 207 /* PRIVATE FUNCTIONS ******************************************************/
 208
 209 // Queries registry for those three file names
 210 static BOOLEAN
 211 WinLdrGetNLSNames(LPSTR AnsiName,
 212                   LPSTR OemName,
 213                   LPSTR LangName)
 214 {
 215     LONG rc = ERROR_SUCCESS;
 216     HKEY hKey;
 217     WCHAR szIdBuffer[80];
 218     WCHAR NameBuffer[80];
 219     ULONG BufferSize;
 220
 221     /* open the codepage key */
 222     rc = RegOpenKey(NULL,
 223         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\CodePage",
 224         &hKey);
 225     if (rc != ERROR_SUCCESS)
 226     {
 227         //strcpy(szErrorOut, "Couldn't open CodePage registry key");
 228         return FALSE;
 229     }
 230
 231     /* Get ANSI codepage */
 232     BufferSize = sizeof(szIdBuffer);
 233     rc = RegQueryValue(hKey, L"ACP", NULL, (PUCHAR)szIdBuffer, &BufferSize);
 234     if (rc != ERROR_SUCCESS)
 235     {
 236         //strcpy(szErrorOut, "Couldn't get ACP NLS setting");
 237         return FALSE;
 238     }
 239
 240     BufferSize = sizeof(NameBuffer);
 241     rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)NameBuffer, &BufferSize);
 242     if (rc != ERROR_SUCCESS)
 243     {
 244         //strcpy(szErrorOut, "ACP NLS Setting exists, but isn't readable");
 245         //return FALSE;
 246         wcscpy(NameBuffer, L"c_1252.nls"); // HACK: ReactOS bug CORE-6105
 247     }
 248     sprintf(AnsiName, "%S", NameBuffer);
 249
 250     /* Get OEM codepage */
 251     BufferSize = sizeof(szIdBuffer);
 252     rc = RegQueryValue(hKey, L"OEMCP", NULL, (PUCHAR)szIdBuffer, &BufferSize);
 253     if (rc != ERROR_SUCCESS)
 254     {
 255         //strcpy(szErrorOut, "Couldn't get OEMCP NLS setting");
 256         return FALSE;
 257     }
 258
 259     BufferSize = sizeof(NameBuffer);
 260     rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)NameBuffer, &BufferSize);
 261     if (rc != ERROR_SUCCESS)
 262     {
 263         //strcpy(szErrorOut, "OEMCP NLS setting exists, but isn't readable");
 264         //return FALSE;
 265         wcscpy(NameBuffer, L"c_437.nls"); // HACK: ReactOS bug CORE-6105
 266     }
 267     sprintf(OemName, "%S", NameBuffer);
 268
 269     /* Open the language key */
 270     rc = RegOpenKey(NULL,
 271         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\Language",
 272         &hKey);
 273     if (rc != ERROR_SUCCESS)
 274     {
 275         //strcpy(szErrorOut, "Couldn't open Language registry key");
 276         return FALSE;
 277     }
 278
 279     /* Get the Unicode case table */
 280     BufferSize = sizeof(szIdBuffer);
 281     rc = RegQueryValue(hKey, L"Default", NULL, (PUCHAR)szIdBuffer, &BufferSize);
 282     if (rc != ERROR_SUCCESS)
 283     {
 284         //strcpy(szErrorOut, "Couldn't get Language Default setting");
 285         return FALSE;
 286     }
 287
 288     BufferSize = sizeof(NameBuffer);
 289     rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)NameBuffer, &BufferSize);
 290     if (rc != ERROR_SUCCESS)
 291     {
 292         //strcpy(szErrorOut, "Language Default setting exists, but isn't readable");
 293         return FALSE;
 294     }
 295     sprintf(LangName, "%S", NameBuffer);
 296
 297     return TRUE;
 298 }
 299
 300 BOOLEAN
 301 WinLdrLoadNLSData(IN OUT PLOADER_PARAMETER_BLOCK LoaderBlock,
 302                   IN LPCSTR DirectoryPath,
 303                   IN LPCSTR AnsiFileName,
 304                   IN LPCSTR OemFileName,
 305                   IN LPCSTR LanguageFileName)
 306 {
 307     CHAR FileName[255];
 308     ULONG AnsiFileId;
 309     ULONG OemFileId;
 310     ULONG LanguageFileId;
 311     ULONG AnsiFileSize, OemFileSize, LanguageFileSize;
 312     ULONG TotalSize;
 313     ULONG_PTR NlsDataBase;
 314     PVOID NlsVirtual;
 315     BOOLEAN AnsiEqualsOem = FALSE;
 316     FILEINFORMATION FileInfo;
 317     ULONG BytesRead;
 318     ARC_STATUS Status;
 319
 320     /* There may be a case, when OEM and ANSI page coincide */
 321     if (!strcmp(AnsiFileName, OemFileName))
 322         AnsiEqualsOem = TRUE;
 323
 324     /* Open file with ANSI and store its size */
 325     strcpy(FileName, DirectoryPath);
 326     strcat(FileName, AnsiFileName);
 327     Status = ArcOpen(FileName, OpenReadOnly, &AnsiFileId);
 328     if (Status != ESUCCESS)
 329     {
 330         WARN("Error while opening '%s', Status: %u\n", FileName, Status);
 331         goto Failure;
 332     }
 333
 334     Status = ArcGetFileInformation(AnsiFileId, &FileInfo);
 335     if (Status != ESUCCESS)
 336         goto Failure;
 337     AnsiFileSize = FileInfo.EndingAddress.LowPart;
 338     TRACE("AnsiFileSize: %d\n", AnsiFileSize);
 339     ArcClose(AnsiFileId);
 340
 341     /* Open OEM file and store its length */
 342     if (AnsiEqualsOem)
 343     {
 344         OemFileSize = 0;
 345     }
 346     else
 347     {
 348         //Print(L"Loading %s...\n", Filename);
 349         strcpy(FileName, DirectoryPath);
 350         strcat(FileName, OemFileName);
 351         Status = ArcOpen(FileName, OpenReadOnly, &OemFileId);
 352         if (Status != ESUCCESS)
 353         {
 354             WARN("Error while opening '%s', Status: %u\n", FileName, Status);
 355             goto Failure;
 356         }
 357
 358         Status = ArcGetFileInformation(OemFileId, &FileInfo);
 359         if (Status != ESUCCESS)
 360             goto Failure;
 361         OemFileSize = FileInfo.EndingAddress.LowPart;
 362         ArcClose(OemFileId);
 363     }
 364     TRACE("OemFileSize: %d\n", OemFileSize);
 365
 366     /* And finally open the language codepage file and store its length */
 367     //Print(L"Loading %s...\n", Filename);
 368     strcpy(FileName, DirectoryPath);
 369     strcat(FileName, LanguageFileName);
 370     Status = ArcOpen(FileName, OpenReadOnly, &LanguageFileId);
 371     if (Status != ESUCCESS)
 372     {
 373         WARN("Error while opening '%s', Status: %u\n", FileName, Status);
 374         goto Failure;
 375     }
 376
 377     Status = ArcGetFileInformation(LanguageFileId, &FileInfo);
 378     if (Status != ESUCCESS)
 379         goto Failure;
 380     LanguageFileSize = FileInfo.EndingAddress.LowPart;
 381     ArcClose(LanguageFileId);
 382     TRACE("LanguageFileSize: %d\n", LanguageFileSize);
 383
 384     /* Sum up all three length, having in mind that every one of them
 385        must start at a page boundary => thus round up each file to a page */
 386     TotalSize = MM_SIZE_TO_PAGES(AnsiFileSize) +
 387         MM_SIZE_TO_PAGES(OemFileSize)  +
 388         MM_SIZE_TO_PAGES(LanguageFileSize);
 389
 390     /* Store it for later marking the pages as NlsData type */
 391     TotalNLSSize = TotalSize;
 392
 393     NlsDataBase = (ULONG_PTR)MmAllocateMemoryWithType(TotalSize*MM_PAGE_SIZE, LoaderNlsData);
 394
 395     if (NlsDataBase == 0)
 396         goto Failure;
 397
 398     NlsVirtual = PaToVa((PVOID)NlsDataBase);
 399     LoaderBlock->NlsData->AnsiCodePageData = NlsVirtual;
 400     LoaderBlock->NlsData->OemCodePageData = (PVOID)((PUCHAR)NlsVirtual +
 401         (MM_SIZE_TO_PAGES(AnsiFileSize) << MM_PAGE_SHIFT));
 402     LoaderBlock->NlsData->UnicodeCodePageData = (PVOID)((PUCHAR)NlsVirtual +
 403         (MM_SIZE_TO_PAGES(AnsiFileSize) << MM_PAGE_SHIFT) +
 404         (MM_SIZE_TO_PAGES(OemFileSize) << MM_PAGE_SHIFT));
 405
 406     /* Ansi and OEM data are the same - just set pointers to the same area */
 407     if (AnsiEqualsOem)
 408         LoaderBlock->NlsData->OemCodePageData = LoaderBlock->NlsData->AnsiCodePageData;
 409
 410
 411     /* Now actually read the data into memory, starting with Ansi file */
 412     strcpy(FileName, DirectoryPath);
 413     strcat(FileName, AnsiFileName);
 414     Status = ArcOpen(FileName, OpenReadOnly, &AnsiFileId);
 415     if (Status != ESUCCESS)
 416     {
 417         WARN("Error while opening '%s', Status: %u\n", FileName, Status);
 418         goto Failure;
 419     }
 420
 421     Status = ArcRead(AnsiFileId, VaToPa(LoaderBlock->NlsData->AnsiCodePageData), AnsiFileSize, &BytesRead);
 422     if (Status != ESUCCESS)
 423     {
 424         WARN("Error while reading '%s', Status: %u\n", FileName, Status);
 425         goto Failure;
 426     }
 427
 428     ArcClose(AnsiFileId);
 429
 430     /* OEM now, if it doesn't equal Ansi of course */
 431     if (!AnsiEqualsOem)
 432     {
 433         strcpy(FileName, DirectoryPath);
 434         strcat(FileName, OemFileName);
 435         Status = ArcOpen(FileName, OpenReadOnly, &OemFileId);
 436         if (Status != ESUCCESS)
 437         {
 438             WARN("Error while opening '%s', Status: %u\n", FileName, Status);
 439             goto Failure;
 440         }
 441
 442         Status = ArcRead(OemFileId, VaToPa(LoaderBlock->NlsData->OemCodePageData), OemFileSize, &BytesRead);
 443         if (Status != ESUCCESS)
 444         {
 445             WARN("Error while reading '%s', Status: %u\n", FileName, Status);
 446             goto Failure;
 447         }
 448
 449         ArcClose(OemFileId);
 450     }
 451
 452     /* finally the language file */
 453     strcpy(FileName, DirectoryPath);
 454     strcat(FileName, LanguageFileName);
 455     Status = ArcOpen(FileName, OpenReadOnly, &LanguageFileId);
 456     if (Status != ESUCCESS)
 457     {
 458         WARN("Error while opening '%s', Status: %u\n", FileName, Status);
 459         goto Failure;
 460     }
 461
 462     Status = ArcRead(LanguageFileId, VaToPa(LoaderBlock->NlsData->UnicodeCodePageData), LanguageFileSize, &BytesRead);
 463     if (Status != ESUCCESS)
 464     {
 465         WARN("Error while reading '%s', Status: %u\n", FileName, Status);
 466         goto Failure;
 467     }
 468
 469     ArcClose(LanguageFileId);
 470
 471     //
 472     // THIS IS HAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAACK
 473     // Should go to WinLdrLoadOemHalFont(), when it will be implemented
 474     //
 475     LoaderBlock->OemFontFile = VaToPa(LoaderBlock->NlsData->UnicodeCodePageData);
 476
 477     /* Convert NlsTables address to VA */
 478     LoaderBlock->NlsData = PaToVa(LoaderBlock->NlsData);
 479
 480     return TRUE;
 481
 482 Failure:
 483     UiMessageBox("Error reading NLS file %s", FileName);
 484     return FALSE;
 485 }
 486
 487 static VOID
 488 WinLdrScanRegistry(IN OUT PLIST_ENTRY BootDriverListHead,
 489                    IN LPCSTR DirectoryPath)
 490 {
 491     LONG rc = 0;
 492     HKEY hGroupKey, hOrderKey, hServiceKey, hDriverKey;
 493     LPWSTR GroupNameBuffer;
 494     WCHAR ServiceName[256];
 495     ULONG OrderList[128];
 496     ULONG BufferSize;
 497     ULONG Index;
 498     ULONG TagIndex;
 499     LPWSTR GroupName;
 500
 501     ULONG ValueSize;
 502     ULONG ValueType;
 503     ULONG StartValue;
 504     ULONG TagValue;
 505     WCHAR DriverGroup[256];
 506     ULONG DriverGroupSize;
 507
 508     CHAR ImagePath[256];
 509     WCHAR TempImagePath[256];
 510
 511     BOOLEAN Success;
 512
 513     /* get 'service group order' key */
 514     rc = RegOpenKey(NULL,
 515         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\ServiceGroupOrder",
 516         &hGroupKey);
 517     if (rc != ERROR_SUCCESS) {
 518
 519         TRACE_CH(REACTOS, "Failed to open the 'ServiceGroupOrder' key (rc %d)\n", (int)rc);
 520         return;
 521     }
 522
 523     /* get 'group order list' key */
 524     rc = RegOpenKey(NULL,
 525         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\GroupOrderList",
 526         &hOrderKey);
 527     if (rc != ERROR_SUCCESS) {
 528
 529         TRACE_CH(REACTOS, "Failed to open the 'GroupOrderList' key (rc %d)\n", (int)rc);
 530         return;
 531     }
 532
 533     /* enumerate drivers */
 534     rc = RegOpenKey(NULL,
 535         L"\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Services",
 536         &hServiceKey);
 537     if (rc != ERROR_SUCCESS)  {
 538
 539         TRACE_CH(REACTOS, "Failed to open the 'Services' key (rc %d)\n", (int)rc);
 540         return;
 541     }
 542
 543     /* Get the Name Group */
 544     BufferSize = 4096;
 545     GroupNameBuffer = FrLdrHeapAlloc(BufferSize, TAG_WLDR_NAME);
 546     rc = RegQueryValue(hGroupKey, L"List", NULL, (PUCHAR)GroupNameBuffer, &BufferSize);
 547     TRACE_CH(REACTOS, "RegQueryValue(): rc %d\n", (int)rc);
 548     if (rc != ERROR_SUCCESS)
 549         return;
 550     TRACE_CH(REACTOS, "BufferSize: %d \n", (int)BufferSize);
 551     TRACE_CH(REACTOS, "GroupNameBuffer: '%S' \n", GroupNameBuffer);
 552
 553     /* Loop through each group */
 554     GroupName = GroupNameBuffer;
 555     while (*GroupName)
 556     {
 557         TRACE("Driver group: '%S'\n", GroupName);
 558
 559         /* Query the Order */
 560         BufferSize = sizeof(OrderList);
 561         rc = RegQueryValue(hOrderKey, GroupName, NULL, (PUCHAR)OrderList, &BufferSize);
 562         if (rc != ERROR_SUCCESS) OrderList[0] = 0;
 563
 564         /* enumerate all drivers */
 565         for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++)
 566         {
 567             Index = 0;
 568
 569             while (TRUE)
 570             {
 571                 /* Get the Driver's Name */
 572                 ValueSize = sizeof(ServiceName);
 573                 rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize, &hDriverKey);
 574                 TRACE("RegEnumKey(): rc %d\n", (int)rc);
 575
 576                 /* Make sure it's valid, and check if we're done */
 577                 if (rc == ERROR_NO_MORE_ITEMS)
 578                     break;
 579                 if (rc != ERROR_SUCCESS)
 580                 {
 581                     FrLdrHeapFree(GroupNameBuffer, TAG_WLDR_NAME);
 582                     return;
 583                 }
 584                 //TRACE_CH(REACTOS, "Service %d: '%S'\n", (int)Index, ServiceName);
 585
 586                 /* Read the Start Value */
 587                 ValueSize = sizeof(ULONG);
 588                 rc = RegQueryValue(hDriverKey, L"Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
 589                 if (rc != ERROR_SUCCESS) StartValue = (ULONG)-1;
 590                 //TRACE_CH(REACTOS, "  Start: %x  \n", (int)StartValue);
 591
 592                 /* Read the Tag */
 593                 ValueSize = sizeof(ULONG);
 594                 rc = RegQueryValue(hDriverKey, L"Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
 595                 if (rc != ERROR_SUCCESS) TagValue = (ULONG)-1;
 596                 //TRACE_CH(REACTOS, "  Tag:   %x  \n", (int)TagValue);
 597
 598                 /* Read the driver's group */
 599                 DriverGroupSize = sizeof(DriverGroup);
 600                 rc = RegQueryValue(hDriverKey, L"Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
 601                 //TRACE_CH(REACTOS, "  Group: '%S'  \n", DriverGroup);
 602
 603                 /* Make sure it should be started */
 604                 if ((StartValue == 0) &&
 605                     (TagValue == OrderList[TagIndex]) &&
 606                     (_wcsicmp(DriverGroup, GroupName) == 0))
 607                 {
 608                     /* Get the Driver's Location */
 609                     ValueSize = sizeof(TempImagePath);
 610                     rc = RegQueryValue(hDriverKey, L"ImagePath", NULL, (PUCHAR)TempImagePath, &ValueSize);
 611
 612                     /* Write the whole path if it succeeded, else prepare to fail */
 613                     if (rc != ERROR_SUCCESS)
 614                     {
 615                         TRACE_CH(REACTOS, "ImagePath: not found\n");
 616                         TempImagePath[0] = 0;
 617                         RtlStringCbPrintfA(ImagePath, sizeof(ImagePath), "%s\\system32\\drivers\\%S.sys", DirectoryPath, ServiceName);
 618                     }
 619                     else if (TempImagePath[0] != L'\\')
 620                     {
 621                         RtlStringCbPrintfA(ImagePath, sizeof(ImagePath), "%s%S", DirectoryPath, TempImagePath);
 622                     }
 623                     else
 624                     {
 625                         RtlStringCbPrintfA(ImagePath, sizeof(ImagePath), "%S", TempImagePath);
 626                         TRACE_CH(REACTOS, "ImagePath: '%s'\n", ImagePath);
 627                     }
 628
 629                     TRACE("Adding boot driver: '%s'\n", ImagePath);
 630
 631                     Success = WinLdrAddDriverToList(BootDriverListHead,
 632                                                     L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\",
 633                                                     TempImagePath,
 634                                                     ServiceName);
 635                     if (!Success)
 636                         ERR("Failed to add boot driver\n");
 637                 }
 638                 else
 639                 {
 640                     //TRACE("  Skipping driver '%S' with Start %d, Tag %d and Group '%S' (Current Tag %d, current group '%S')\n",
 641                     //    ServiceName, StartValue, TagValue, DriverGroup, OrderList[TagIndex], GroupName);
 642                 }
 643
 644                 Index++;
 645             }
 646         }
 647
 648         Index = 0;
 649         while (TRUE)
 650         {
 651             /* Get the Driver's Name */
 652             ValueSize = sizeof(ServiceName);
 653             rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize, &hDriverKey);
 654
 655             //TRACE_CH(REACTOS, "RegEnumKey(): rc %d\n", (int)rc);
 656             if (rc == ERROR_NO_MORE_ITEMS)
 657                 break;
 658             if (rc != ERROR_SUCCESS)
 659             {
 660                 FrLdrHeapFree(GroupNameBuffer, TAG_WLDR_NAME);
 661                 return;
 662             }
 663             TRACE("Service %d: '%S'\n", (int)Index, ServiceName);
 664
 665             /* Read the Start Value */
 666             ValueSize = sizeof(ULONG);
 667             rc = RegQueryValue(hDriverKey, L"Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
 668             if (rc != ERROR_SUCCESS) StartValue = (ULONG)-1;
 669             //TRACE_CH(REACTOS, "  Start: %x  \n", (int)StartValue);
 670
 671             /* Read the Tag */
 672             ValueSize = sizeof(ULONG);
 673             rc = RegQueryValue(hDriverKey, L"Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
 674             if (rc != ERROR_SUCCESS) TagValue = (ULONG)-1;
 675             //TRACE_CH(REACTOS, "  Tag:   %x  \n", (int)TagValue);
 676
 677             /* Read the driver's group */
 678             DriverGroupSize = sizeof(DriverGroup);
 679             rc = RegQueryValue(hDriverKey, L"Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
 680             //TRACE_CH(REACTOS, "  Group: '%S'  \n", DriverGroup);
 681
 682             for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++)
 683             {
 684                 if (TagValue == OrderList[TagIndex]) break;
 685             }
 686
 687             if ((StartValue == 0) &&
 688                 (TagIndex > OrderList[0]) &&
 689                 (_wcsicmp(DriverGroup, GroupName) == 0))
 690             {
 691                 ValueSize = sizeof(TempImagePath);
 692                 rc = RegQueryValue(hDriverKey, L"ImagePath", NULL, (PUCHAR)TempImagePath, &ValueSize);
 693                 if (rc != ERROR_SUCCESS)
 694                 {
 695                     TRACE_CH(REACTOS, "ImagePath: not found\n");
 696                     TempImagePath[0] = 0;
 697                     RtlStringCbPrintfA(ImagePath, sizeof(ImagePath), "%ssystem32\\drivers\\%S.sys", DirectoryPath, ServiceName);
 698                 }
 699                 else if (TempImagePath[0] != L'\\')
 700                 {
 701                     RtlStringCbPrintfA(ImagePath, sizeof(ImagePath), "%s%S", DirectoryPath, TempImagePath);
 702                 }
 703                 else
 704                 {
 705                     RtlStringCbPrintfA(ImagePath, sizeof(ImagePath), "%S", TempImagePath);
 706                     TRACE_CH(REACTOS, "ImagePath: '%s'\n", ImagePath);
 707                 }
 708                 TRACE("  Adding boot driver: '%s'\n", ImagePath);
 709
 710                 Success = WinLdrAddDriverToList(BootDriverListHead,
 711                                                 L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\",
 712                                                 TempImagePath,
 713                                                 ServiceName);
 714                 if (!Success)
 715                     ERR(" Failed to add boot driver\n");
 716             }
 717             else
 718             {
 719                 //TRACE("  Skipping driver '%S' with Start %d, Tag %d and Group '%S' (Current group '%S')\n",
 720                 //    ServiceName, StartValue, TagValue, DriverGroup, GroupName);
 721             }
 722
 723             Index++;
 724         }
 725
 726         /* Move to the next group name */
 727         GroupName = GroupName + wcslen(GroupName) + 1;
 728     }
 729
 730     /* Free allocated memory */
 731     FrLdrHeapFree(GroupNameBuffer, TAG_WLDR_NAME);
 732 }
 733
 734 static
 735 BOOLEAN
 736 InsertInBootDriverList(
 737     PLIST_ENTRY BootDriverListHead,
 738     PBOOT_DRIVER_LIST_ENTRY BootDriverEntry)
 739 {
 740     PBOOT_DRIVER_LIST_ENTRY DriverEntry;
 741     PLIST_ENTRY ListEntry;
 742
 743     ASSERT(BootDriverEntry->FilePath.Buffer != NULL);
 744     ASSERT(BootDriverEntry->RegistryPath.Buffer != NULL);
 745
 746     for (ListEntry = BootDriverListHead->Flink;
 747          ListEntry != BootDriverListHead;
 748          ListEntry = ListEntry->Flink)
 749     {
 750         DriverEntry = CONTAINING_RECORD(ListEntry,
 751                                         BOOT_DRIVER_LIST_ENTRY,
 752                                         Link);
 753         if ((DriverEntry->FilePath.Buffer != NULL) &&
 754             RtlEqualUnicodeString(&BootDriverEntry->FilePath,
 755                                   &DriverEntry->FilePath,
 756                                   TRUE))
 757         {
 758             return FALSE;
 759         }
 760
 761         if ((DriverEntry->RegistryPath.Buffer != NULL) &&
 762             RtlEqualUnicodeString(&BootDriverEntry->RegistryPath,
 763                                   &DriverEntry->RegistryPath,
 764                                   TRUE))
 765         {
 766             return FALSE;
 767         }
 768     }
 769
 770     InsertTailList(BootDriverListHead, &BootDriverEntry->Link);
 771     return TRUE;
 772 }
 773
 774 BOOLEAN
 775 WinLdrAddDriverToList(LIST_ENTRY *BootDriverListHead,
 776                       LPWSTR RegistryPath,
 777                       LPWSTR ImagePath,
 778                       LPWSTR ServiceName)
 779 {
 780     PBOOT_DRIVER_LIST_ENTRY BootDriverEntry;
 781     NTSTATUS Status;
 782     USHORT PathLength;
 783
 784     BootDriverEntry = FrLdrHeapAlloc(sizeof(BOOT_DRIVER_LIST_ENTRY), TAG_WLDR_BDE);
 785
 786     if (!BootDriverEntry)
 787         return FALSE;
 788
 789     // DTE will be filled during actual load of the driver
 790     BootDriverEntry->LdrEntry = NULL;
 791
 792     // Check - if we have a valid ImagePath, if not - we need to build it
 793     // like "System32\\Drivers\\blah.sys"
 794     if (ImagePath && (ImagePath[0] != 0))
 795     {
 796         // Just copy ImagePath to the corresponding field in the structure
 797         PathLength = (USHORT)wcslen(ImagePath) * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 798
 799         BootDriverEntry->FilePath.Length = 0;
 800         BootDriverEntry->FilePath.MaximumLength = PathLength;
 801         BootDriverEntry->FilePath.Buffer = FrLdrHeapAlloc(PathLength, TAG_WLDR_NAME);
 802
 803         if (!BootDriverEntry->FilePath.Buffer)
 804         {
 805             FrLdrHeapFree(BootDriverEntry, TAG_WLDR_BDE);
 806             return FALSE;
 807         }
 808
 809         Status = RtlAppendUnicodeToString(&BootDriverEntry->FilePath, ImagePath);
 810         if (!NT_SUCCESS(Status))
 811         {
 812             FrLdrHeapFree(BootDriverEntry->FilePath.Buffer, TAG_WLDR_NAME);
 813             FrLdrHeapFree(BootDriverEntry, TAG_WLDR_BDE);
 814             return FALSE;
 815         }
 816     }
 817     else
 818     {
 819         // we have to construct ImagePath ourselves
 820         PathLength = (USHORT)wcslen(ServiceName)*sizeof(WCHAR) + sizeof(L"system32\\drivers\\.sys");
 821         BootDriverEntry->FilePath.Length = 0;
 822         BootDriverEntry->FilePath.MaximumLength = PathLength;
 823         BootDriverEntry->FilePath.Buffer = FrLdrHeapAlloc(PathLength, TAG_WLDR_NAME);
 824
 825         if (!BootDriverEntry->FilePath.Buffer)
 826         {
 827             FrLdrHeapFree(BootDriverEntry, TAG_WLDR_NAME);
 828             return FALSE;
 829         }
 830
 831         Status = RtlAppendUnicodeToString(&BootDriverEntry->FilePath, L"system32\\drivers\\");
 832         if (!NT_SUCCESS(Status))
 833         {
 834             FrLdrHeapFree(BootDriverEntry->FilePath.Buffer, TAG_WLDR_NAME);
 835             FrLdrHeapFree(BootDriverEntry, TAG_WLDR_NAME);
 836             return FALSE;
 837         }
 838
 839         Status = RtlAppendUnicodeToString(&BootDriverEntry->FilePath, ServiceName);
 840         if (!NT_SUCCESS(Status))
 841         {
 842             FrLdrHeapFree(BootDriverEntry->FilePath.Buffer, TAG_WLDR_NAME);
 843             FrLdrHeapFree(BootDriverEntry, TAG_WLDR_NAME);
 844             return FALSE;
 845         }
 846
 847         Status = RtlAppendUnicodeToString(&BootDriverEntry->FilePath, L".sys");
 848         if (!NT_SUCCESS(Status))
 849         {
 850             FrLdrHeapFree(BootDriverEntry->FilePath.Buffer, TAG_WLDR_NAME);
 851             FrLdrHeapFree(BootDriverEntry, TAG_WLDR_NAME);
 852             return FALSE;
 853         }
 854     }
 855
 856     // Add registry path
 857     PathLength = (USHORT)(wcslen(RegistryPath) + wcslen(ServiceName))*sizeof(WCHAR) + sizeof(UNICODE_NULL);
 858     BootDriverEntry->RegistryPath.Length = 0;
 859     BootDriverEntry->RegistryPath.MaximumLength = PathLength;
 860     BootDriverEntry->RegistryPath.Buffer = FrLdrHeapAlloc(PathLength, TAG_WLDR_NAME);
 861     if (!BootDriverEntry->RegistryPath.Buffer)
 862         return FALSE;
 863
 864     Status = RtlAppendUnicodeToString(&BootDriverEntry->RegistryPath, RegistryPath);
 865     if (!NT_SUCCESS(Status))
 866         return FALSE;
 867
 868     Status = RtlAppendUnicodeToString(&BootDriverEntry->RegistryPath, ServiceName);
 869     if (!NT_SUCCESS(Status))
 870         return FALSE;
 871
 872     // Insert entry into the list
 873     if (!InsertInBootDriverList(BootDriverListHead, BootDriverEntry))
 874     {
 875         // It was already there, so delete our entry
 876         if (BootDriverEntry->FilePath.Buffer) FrLdrHeapFree(BootDriverEntry->FilePath.Buffer, TAG_WLDR_NAME);
 877         if (BootDriverEntry->RegistryPath.Buffer) FrLdrHeapFree(BootDriverEntry->RegistryPath.Buffer, TAG_WLDR_NAME);
 878         FrLdrHeapFree(BootDriverEntry, TAG_WLDR_BDE);
 879     }
 880
 881     return TRUE;
 882 }