1 /* 2 * PROJECT: ReactOS Application compatibility module 3 * LICENSE: GPL-2.0+ (https://spdx.org/licenses/GPL-2.0+) 4 * PURPOSE: Sdb low level glue layer 5 * COPYRIGHT: Copyright 2011 André Hentschel 6 * Copyright 2013 Mislav Blaževic 7 * Copyright 2015-2018 Mark Jansen (mark.jansen@reactos.org) 8 */ 9 10 #include "ntndk.h" 11 #include "strsafe.h" 12 #include "apphelp.h" 13 #include "sdbstringtable.h" 14 15 16 static const GUID GUID_DATABASE_MSI = {0xd8ff6d16,0x6a3a,0x468a, {0x8b,0x44,0x01,0x71,0x4d,0xdc,0x49,0xea}}; 17 static const GUID GUID_DATABASE_SHIM = {0x11111111,0x1111,0x1111, {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11}}; 18 static const GUID GUID_DATABASE_DRIVERS = {0xf9ab2228,0x3312,0x4a73, {0xb6,0xf9,0x93,0x6d,0x70,0xe1,0x12,0xef}}; 19 20 static HANDLE SdbpHeap(void); 21 22 #if SDBAPI_DEBUG_ALLOC 23 24 /* dbgheap.c */ 25 void SdbpInsertAllocation(PVOID address, SIZE_T size, int line, const char* file); 26 void SdbpUpdateAllocation(PVOID address, PVOID newaddress, SIZE_T size, int line, const char* file); 27 void SdbpRemoveAllocation(PVOID address, int line, const char* file); 28 void SdbpDebugHeapInit(HANDLE privateHeapPtr); 29 void SdbpDebugHeapDeinit(void); 30 31 #endif 32 33 static HANDLE g_Heap; 34 void SdbpHeapInit(void) 35 { 36 g_Heap = RtlCreateHeap(HEAP_GROWABLE, NULL, 0, 0x10000, NULL, NULL); 37 #if SDBAPI_DEBUG_ALLOC 38 SdbpDebugHeapInit(g_Heap); 39 #endif 40 } 41 42 void SdbpHeapDeinit(void) 43 { 44 #if SDBAPI_DEBUG_ALLOC 45 SdbpDebugHeapDeinit(); 46 #endif 47 RtlDestroyHeap(g_Heap); 48 } 49 50 static HANDLE SdbpHeap(void) 51 { 52 return g_Heap; 53 } 54 55 LPVOID SdbpAlloc(SIZE_T size 56 #if SDBAPI_DEBUG_ALLOC 57 , int line, const char* file 58 #endif 59 ) 60 { 61 LPVOID mem = RtlAllocateHeap(SdbpHeap(), HEAP_ZERO_MEMORY, size); 62 #if SDBAPI_DEBUG_ALLOC 63 SdbpInsertAllocation(mem, size, line, file); 64 #endif 65 return mem; 66 } 67 68 LPVOID SdbpReAlloc(LPVOID mem, SIZE_T size, SIZE_T oldSize 69 #if SDBAPI_DEBUG_ALLOC 70 , int line, const char* file 71 #endif 72 ) 73 { 74 LPVOID newmem = RtlReAllocateHeap(SdbpHeap(), HEAP_ZERO_MEMORY, mem, size); 75 #if SDBAPI_DEBUG_ALLOC 76 SdbpUpdateAllocation(mem, newmem, size, line, file); 77 #endif 78 return newmem; 79 } 80 81 void SdbpFree(LPVOID mem 82 #if SDBAPI_DEBUG_ALLOC 83 , int line, const char* file 84 #endif 85 ) 86 { 87 #if SDBAPI_DEBUG_ALLOC 88 SdbpRemoveAllocation(mem, line, file); 89 #endif 90 RtlFreeHeap(SdbpHeap(), 0, mem); 91 } 92 93 PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write) 94 { 95 NTSTATUS Status; 96 IO_STATUS_BLOCK io; 97 OBJECT_ATTRIBUTES attr; 98 UNICODE_STRING str; 99 PDB pdb; 100 101 if (type == DOS_PATH) 102 { 103 if (!RtlDosPathNameToNtPathName_U(path, &str, NULL, NULL)) 104 return NULL; 105 } 106 else 107 { 108 RtlInitUnicodeString(&str, path); 109 } 110 111 /* SdbAlloc zeroes the memory. */ 112 pdb = (PDB)SdbAlloc(sizeof(DB)); 113 if (!pdb) 114 { 115 SHIM_ERR("Failed to allocate memory for shim database\n"); 116 return NULL; 117 } 118 119 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, NULL, NULL); 120 121 Status = NtCreateFile(&pdb->file, (write ? FILE_GENERIC_WRITE : FILE_GENERIC_READ )| SYNCHRONIZE, 122 &attr, &io, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, 123 write ? FILE_SUPERSEDE : FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0); 124 125 pdb->for_write = write; 126 127 if (type == DOS_PATH) 128 RtlFreeUnicodeString(&str); 129 130 if (!NT_SUCCESS(Status)) 131 { 132 SdbCloseDatabase(pdb); 133 SHIM_ERR("Failed to create shim database file: %lx\n", Status); 134 return NULL; 135 } 136 137 return pdb; 138 } 139 140 void WINAPI SdbpFlush(PDB pdb) 141 { 142 IO_STATUS_BLOCK io; 143 NTSTATUS Status; 144 145 ASSERT(pdb->for_write); 146 Status = NtWriteFile(pdb->file, NULL, NULL, NULL, &io, 147 pdb->data, pdb->write_iter, NULL, NULL); 148 if( !NT_SUCCESS(Status)) 149 SHIM_WARN("failed with 0x%lx\n", Status); 150 } 151 152 DWORD SdbpStrlen(PCWSTR string) 153 { 154 return wcslen(string); 155 } 156 157 DWORD SdbpStrsize(PCWSTR string) 158 { 159 return (SdbpStrlen(string) + 1) * sizeof(WCHAR); 160 } 161 162 PWSTR SdbpStrDup(LPCWSTR string) 163 { 164 PWSTR ret = SdbAlloc(SdbpStrsize(string)); 165 wcscpy(ret, string); 166 return ret; 167 } 168 169 170 BOOL WINAPI SdbpOpenMemMappedFile(LPCWSTR path, PMEMMAPPED mapping) 171 { 172 NTSTATUS Status; 173 OBJECT_ATTRIBUTES ObjectAttributes; 174 IO_STATUS_BLOCK IoStatusBlock; 175 FILE_STANDARD_INFORMATION FileStandard; 176 UNICODE_STRING FileName; 177 178 RtlZeroMemory(mapping, sizeof(*mapping)); 179 180 RtlInitUnicodeString(&FileName, path); 181 182 InitializeObjectAttributes(&ObjectAttributes, &FileName, OBJ_CASE_INSENSITIVE, NULL, NULL); 183 Status = NtOpenFile(&mapping->file, GENERIC_READ | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT); 184 185 if (Status == STATUS_OBJECT_NAME_INVALID || Status == STATUS_OBJECT_PATH_SYNTAX_BAD) 186 { 187 if (!RtlDosPathNameToNtPathName_U(path, &FileName, NULL, NULL)) 188 { 189 SHIM_ERR("Failed to convert %S to Nt path: 0x%lx\n", path, Status); 190 return FALSE; 191 } 192 InitializeObjectAttributes(&ObjectAttributes, &FileName, OBJ_CASE_INSENSITIVE, NULL, NULL); 193 Status = NtOpenFile(&mapping->file, GENERIC_READ | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT); 194 RtlFreeUnicodeString(&FileName); 195 } 196 197 if (!NT_SUCCESS(Status)) 198 { 199 SHIM_ERR("Failed to open file %S: 0x%lx\n", path, Status); 200 return FALSE; 201 } 202 203 Status = NtCreateSection(&mapping->section, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ, 0, 0, PAGE_READONLY, SEC_COMMIT, mapping->file); 204 if (!NT_SUCCESS(Status)) 205 { 206 /* Special case */ 207 if (Status == STATUS_MAPPED_FILE_SIZE_ZERO) 208 { 209 NtClose(mapping->file); 210 mapping->file = mapping->section = NULL; 211 return TRUE; 212 } 213 SHIM_ERR("Failed to create mapping for file: 0x%lx\n", Status); 214 goto err_out; 215 } 216 217 Status = NtQueryInformationFile(mapping->file, &IoStatusBlock, &FileStandard, sizeof(FileStandard), FileStandardInformation); 218 if (!NT_SUCCESS(Status)) 219 { 220 SHIM_ERR("Failed to read file info for file: 0x%lx\n", Status); 221 goto err_out; 222 } 223 224 mapping->mapped_size = mapping->size = FileStandard.EndOfFile.LowPart; 225 Status = NtMapViewOfSection(mapping->section, NtCurrentProcess(), (PVOID*)&mapping->view, 0, 0, 0, &mapping->mapped_size, ViewUnmap, 0, PAGE_READONLY); 226 if (!NT_SUCCESS(Status)) 227 { 228 SHIM_ERR("Failed to map view of file: 0x%lx\n", Status); 229 goto err_out; 230 } 231 232 return TRUE; 233 234 err_out: 235 if (!mapping->view) 236 { 237 if (mapping->section) 238 NtClose(mapping->section); 239 NtClose(mapping->file); 240 } 241 return FALSE; 242 } 243 244 void WINAPI SdbpCloseMemMappedFile(PMEMMAPPED mapping) 245 { 246 /* Prevent a VAD warning */ 247 if (mapping->view) 248 NtUnmapViewOfSection(NtCurrentProcess(), mapping->view); 249 NtClose(mapping->section); 250 NtClose(mapping->file); 251 RtlZeroMemory(mapping, sizeof(*mapping)); 252 } 253 254 BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type) 255 { 256 if ((tag & TAG_TYPE_MASK) != type) 257 return FALSE; 258 return TRUE; 259 } 260 261 BOOL WINAPI SdbpCheckTagIDType(PDB pdb, TAGID tagid, WORD type) 262 { 263 TAG tag = SdbGetTagFromTagID(pdb, tagid); 264 if (tag == TAG_NULL) 265 return FALSE; 266 return SdbpCheckTagType(tag, type); 267 } 268 269 PDB SdbpOpenDatabase(LPCWSTR path, PATH_TYPE type, PDWORD major, PDWORD minor) 270 { 271 IO_STATUS_BLOCK io; 272 FILE_STANDARD_INFORMATION fsi; 273 PDB pdb; 274 NTSTATUS Status; 275 BYTE header[12]; 276 277 pdb = SdbpCreate(path, type, FALSE); 278 if (!pdb) 279 return NULL; 280 281 Status = NtQueryInformationFile(pdb->file, &io, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation); 282 if (!NT_SUCCESS(Status)) 283 { 284 SdbCloseDatabase(pdb); 285 SHIM_ERR("Failed to get shim database size: 0x%lx\n", Status); 286 return NULL; 287 } 288 289 pdb->size = fsi.EndOfFile.u.LowPart; 290 pdb->data = SdbAlloc(pdb->size); 291 Status = NtReadFile(pdb->file, NULL, NULL, NULL, &io, pdb->data, pdb->size, NULL, NULL); 292 293 if (!NT_SUCCESS(Status)) 294 { 295 SdbCloseDatabase(pdb); 296 SHIM_ERR("Failed to open shim database file: 0x%lx\n", Status); 297 return NULL; 298 } 299 300 if (!SdbpReadData(pdb, &header, 0, 12)) 301 { 302 SdbCloseDatabase(pdb); 303 SHIM_ERR("Failed to read shim database header\n"); 304 return NULL; 305 } 306 307 if (memcmp(&header[8], "sdbf", 4) != 0) 308 { 309 SdbCloseDatabase(pdb); 310 SHIM_ERR("Shim database header is invalid\n"); 311 return NULL; 312 } 313 314 *major = *(DWORD*)&header[0]; 315 *minor = *(DWORD*)&header[4]; 316 317 return pdb; 318 } 319 320 321 /** 322 * Opens specified shim database file. 323 * 324 * @param [in] path Path to the shim database. 325 * @param [in] type Type of path. Either DOS_PATH or NT_PATH. 326 * 327 * @return Success: Handle to the shim database, NULL otherwise. 328 */ 329 PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type) 330 { 331 PDB pdb; 332 DWORD major, minor; 333 334 pdb = SdbpOpenDatabase(path, type, &major, &minor); 335 if (!pdb) 336 return NULL; 337 338 if (major != 2 && major != 3) 339 { 340 SdbCloseDatabase(pdb); 341 SHIM_ERR("Invalid shim database version\n"); 342 return NULL; 343 } 344 345 pdb->stringtable = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_STRINGTABLE); 346 if(!SdbGetDatabaseID(pdb, &pdb->database_id)) 347 { 348 SHIM_INFO("Failed to get the database id\n"); 349 } 350 return pdb; 351 } 352 353 /** 354 * Closes specified database and frees its memory. 355 * 356 * @param [in] pdb Handle to the shim database. 357 */ 358 void WINAPI SdbCloseDatabase(PDB pdb) 359 { 360 if (!pdb) 361 return; 362 363 if (pdb->file) 364 NtClose(pdb->file); 365 if (pdb->string_buffer) 366 SdbCloseDatabase(pdb->string_buffer); 367 if (pdb->string_lookup) 368 SdbpTableDestroy(&pdb->string_lookup); 369 SdbFree(pdb->data); 370 SdbFree(pdb); 371 } 372 373 /** 374 * Parses a string to retrieve a GUID. 375 * 376 * @param [in] GuidString The string to parse. 377 * @param [out] Guid The resulting GUID. 378 * 379 * @return TRUE if it succeeds, FALSE if it fails. 380 */ 381 BOOL WINAPI SdbGUIDFromString(PCWSTR GuidString, GUID *Guid) 382 { 383 UNICODE_STRING GuidString_u; 384 RtlInitUnicodeString(&GuidString_u, GuidString); 385 return NT_SUCCESS(RtlGUIDFromString(&GuidString_u, Guid)); 386 } 387 388 /** 389 * Converts a GUID to a string. 390 * 391 * @param [in] Guid The GUID to convert. 392 * @param [out] GuidString The resulting string representation of Guid. 393 * @param [in] Length The length of GuidString. 394 * 395 * @return TRUE if it succeeds, FALSE if it fails. 396 */ 397 BOOL WINAPI SdbGUIDToString(CONST GUID *Guid, PWSTR GuidString, SIZE_T Length) 398 { 399 UNICODE_STRING GuidString_u; 400 if(NT_SUCCESS(RtlStringFromGUID(Guid, &GuidString_u))) 401 { 402 HRESULT hr = StringCchCopyNW(GuidString, Length, GuidString_u.Buffer, GuidString_u.Length / 2); 403 RtlFreeUnicodeString(&GuidString_u); 404 return SUCCEEDED(hr); 405 } 406 return FALSE; 407 } 408 409 /** 410 * Checks if the specified GUID is a NULL GUID 411 * 412 * @param [in] Guid The GUID to check. 413 * 414 * @return TRUE if it is a NULL GUID. 415 */ 416 BOOL WINAPI SdbIsNullGUID(CONST GUID *Guid) 417 { 418 static GUID NullGuid = { 0 }; 419 return !Guid || IsEqualGUID(&NullGuid, Guid); 420 } 421 422 /** 423 * Get the GUID from one of the standard databases. 424 * 425 * @param [in] Flags The ID to retrieve the guid from. (See SDB_DATABASE_MAIN_[xxx]) 426 * @param [out] Guid The resulting GUID. 427 * 428 * @return TRUE if a known database ID. 429 */ 430 BOOL WINAPI SdbGetStandardDatabaseGUID(DWORD Flags, GUID* Guid) 431 { 432 const GUID* copy_from = NULL; 433 switch(Flags & HID_DATABASE_TYPE_MASK) 434 { 435 case SDB_DATABASE_MAIN_MSI: 436 copy_from = &GUID_DATABASE_MSI; 437 break; 438 case SDB_DATABASE_MAIN_SHIM: 439 copy_from = &GUID_DATABASE_SHIM; 440 break; 441 case SDB_DATABASE_MAIN_DRIVERS: 442 copy_from = &GUID_DATABASE_DRIVERS; 443 break; 444 default: 445 SHIM_ERR("Cannot obtain database guid for databases other than main\n"); 446 return FALSE; 447 } 448 if(Guid) 449 { 450 memcpy(Guid, copy_from, sizeof(GUID)); 451 } 452 return TRUE; 453 } 454 455 /** 456 * Read the database version from the specified database. 457 * 458 * @param [in] database The database. 459 * @param [out] VersionHi The first part of the version number. 460 * @param [out] VersionLo The second part of the version number. 461 * 462 * @return TRUE if it succeeds or fails, FALSE if ??? 463 */ 464 BOOL WINAPI SdbGetDatabaseVersion(LPCWSTR database, PDWORD VersionHi, PDWORD VersionLo) 465 { 466 PDB pdb; 467 468 pdb = SdbpOpenDatabase(database, DOS_PATH, VersionHi, VersionLo); 469 if (pdb) 470 SdbCloseDatabase(pdb); 471 472 return TRUE; 473 } 474 475 476 /** 477 * Find the first named child tag. 478 * 479 * @param [in] pdb The database. 480 * @param [in] root The tag to start at 481 * @param [in] find The tag type to find 482 * @param [in] nametag The child of 'find' that contains the name 483 * @param [in] find_name The name to find 484 * 485 * @return The found tag, or TAGID_NULL on failure 486 */ 487 TAGID WINAPI SdbFindFirstNamedTag(PDB pdb, TAGID root, TAGID find, TAGID nametag, LPCWSTR find_name) 488 { 489 TAGID iter; 490 491 iter = SdbFindFirstTag(pdb, root, find); 492 493 while (iter != TAGID_NULL) 494 { 495 TAGID tmp = SdbFindFirstTag(pdb, iter, nametag); 496 if (tmp != TAGID_NULL) 497 { 498 LPCWSTR name = SdbGetStringTagPtr(pdb, tmp); 499 if (name && !wcsicmp(name, find_name)) 500 return iter; 501 } 502 iter = SdbFindNextTag(pdb, root, iter); 503 } 504 return TAGID_NULL; 505 } 506 507 508 /** 509 * Find a named layer in a multi-db. 510 * 511 * @param [in] hsdb The multi-database. 512 * @param [in] layerName The named tag to find. 513 * 514 * @return The layer, or TAGREF_NULL on failure 515 */ 516 TAGREF WINAPI SdbGetLayerTagRef(HSDB hsdb, LPCWSTR layerName) 517 { 518 PDB pdb = hsdb->pdb; 519 520 TAGID database = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE); 521 if (database != TAGID_NULL) 522 { 523 TAGID layer = SdbFindFirstNamedTag(pdb, database, TAG_LAYER, TAG_NAME, layerName); 524 if (layer != TAGID_NULL) 525 { 526 TAGREF tr; 527 if (SdbTagIDToTagRef(hsdb, pdb, layer, &tr)) 528 { 529 return tr; 530 } 531 } 532 } 533 return TAGREF_NULL; 534 } 535 536 537 #ifndef REG_SZ 538 #define REG_SZ 1 539 #define REG_DWORD 4 540 #define REG_QWORD 11 541 #endif 542 543 544 /** 545 * Retrieve a Data entry 546 * 547 * @param [in] pdb The database. 548 * @param [in] tiExe The tagID to start at 549 * @param [in,opt] lpszDataName The name of the Data entry to find, or NULL to return all. 550 * @param [out,opt] lpdwDataType Any of REG_SZ, REG_QWORD, REG_DWORD, ... 551 * @param [out] lpBuffer The output buffer 552 * @param [in,out,opt] lpcbBufferSize The size of lpBuffer in bytes 553 * @param [out,opt] ptiData The tagID of the data 554 * 555 * @return ERROR_SUCCESS 556 */ 557 DWORD WINAPI SdbQueryDataExTagID(PDB pdb, TAGID tiExe, LPCWSTR lpszDataName, LPDWORD lpdwDataType, LPVOID lpBuffer, LPDWORD lpcbBufferSize, TAGID *ptiData) 558 { 559 TAGID tiData, tiValueType, tiValue; 560 DWORD dwDataType, dwSizeRequired, dwInputSize; 561 LPCWSTR lpStringData; 562 /* Not supported yet */ 563 if (!lpszDataName) 564 return ERROR_INVALID_PARAMETER; 565 566 tiData = SdbFindFirstNamedTag(pdb, tiExe, TAG_DATA, TAG_NAME, lpszDataName); 567 if (tiData == TAGID_NULL) 568 { 569 SHIM_INFO("No data tag found\n"); 570 return ERROR_NOT_FOUND; 571 } 572 573 if (ptiData) 574 *ptiData = tiData; 575 576 tiValueType = SdbFindFirstTag(pdb, tiData, TAG_DATA_VALUETYPE); 577 if (tiValueType == TAGID_NULL) 578 { 579 SHIM_WARN("Data tag (0x%x) without valuetype\n", tiData); 580 return ERROR_INTERNAL_DB_CORRUPTION; 581 } 582 583 dwDataType = SdbReadDWORDTag(pdb, tiValueType, 0); 584 switch (dwDataType) 585 { 586 case REG_SZ: 587 tiValue = SdbFindFirstTag(pdb, tiData, TAG_DATA_STRING); 588 break; 589 case REG_DWORD: 590 tiValue = SdbFindFirstTag(pdb, tiData, TAG_DATA_DWORD); 591 break; 592 case REG_QWORD: 593 tiValue = SdbFindFirstTag(pdb, tiData, TAG_DATA_QWORD); 594 break; 595 default: 596 /* Not supported (yet) */ 597 SHIM_WARN("Unsupported dwDataType=0x%x\n", dwDataType); 598 return ERROR_INVALID_PARAMETER; 599 } 600 601 if (lpdwDataType) 602 *lpdwDataType = dwDataType; 603 604 if (tiValue == TAGID_NULL) 605 { 606 SHIM_WARN("Data tag (0x%x) without data\n", tiData); 607 return ERROR_INTERNAL_DB_CORRUPTION; 608 } 609 610 if (dwDataType != REG_SZ) 611 { 612 dwSizeRequired = SdbGetTagDataSize(pdb, tiValue); 613 } 614 else 615 { 616 lpStringData = SdbpGetString(pdb, tiValue, &dwSizeRequired); 617 if (lpStringData == NULL) 618 { 619 return ERROR_INTERNAL_DB_CORRUPTION; 620 } 621 } 622 if (!lpcbBufferSize) 623 return ERROR_INSUFFICIENT_BUFFER; 624 625 dwInputSize = *lpcbBufferSize; 626 *lpcbBufferSize = dwSizeRequired; 627 628 if (dwInputSize < dwSizeRequired || lpBuffer == NULL) 629 { 630 SHIM_WARN("dwInputSize %u not sufficient to hold %u bytes\n", dwInputSize, dwSizeRequired); 631 return ERROR_INSUFFICIENT_BUFFER; 632 } 633 634 if (dwDataType != REG_SZ) 635 { 636 SdbpReadData(pdb, lpBuffer, tiValue + sizeof(TAG), dwSizeRequired); 637 } 638 else 639 { 640 StringCbCopyNW(lpBuffer, dwInputSize, lpStringData, dwSizeRequired); 641 } 642 643 return ERROR_SUCCESS; 644 } 645 646 647 /** 648 * Converts the specified string to an index key. 649 * 650 * @param [in] str The string which will be converted. 651 * 652 * @return The resulting index key 653 * 654 * @todo: Fix this for unicode strings. 655 */ 656 LONGLONG WINAPI SdbMakeIndexKeyFromString(LPCWSTR str) 657 { 658 LONGLONG result = 0; 659 int shift = 56; 660 661 while (*str && shift >= 0) 662 { 663 WCHAR c = toupper(*(str++)); 664 665 if (c & 0xff) 666 { 667 result |= (((LONGLONG)(c & 0xff)) << shift); 668 shift -= 8; 669 } 670 671 if (shift < 0) 672 break; 673 674 c >>= 8; 675 676 if (c & 0xff) 677 { 678 result |= (((LONGLONG)(c & 0xff)) << shift); 679 shift -= 8; 680 } 681 } 682 683 return result; 684 } 685 686 687 /** 688 * Converts specified tag into a string. 689 * 690 * @param [in] tag The tag which will be converted to a string. 691 * 692 * @return Success: Pointer to the string matching specified tag, or L"InvalidTag" on failure. 693 * 694 */ 695 LPCWSTR WINAPI SdbTagToString(TAG tag) 696 { 697 switch (tag) 698 { 699 case TAG_NULL: return L"NULL"; 700 701 /* TAG_TYPE_NULL */ 702 case TAG_INCLUDE: return L"INCLUDE"; 703 case TAG_GENERAL: return L"GENERAL"; 704 case TAG_MATCH_LOGIC_NOT: return L"MATCH_LOGIC_NOT"; 705 case TAG_APPLY_ALL_SHIMS: return L"APPLY_ALL_SHIMS"; 706 case TAG_USE_SERVICE_PACK_FILES: return L"USE_SERVICE_PACK_FILES"; 707 case TAG_MITIGATION_OS: return L"MITIGATION_OS"; 708 case TAG_BLOCK_UPGRADE: return L"BLOCK_UPGRADE"; 709 case TAG_INCLUDEEXCLUDEDLL: return L"INCLUDEEXCLUDEDLL"; 710 case TAG_RAC_EVENT_OFF: return L"RAC_EVENT_OFF"; 711 case TAG_TELEMETRY_OFF: return L"TELEMETRY_OFF"; 712 case TAG_SHIM_ENGINE_OFF: return L"SHIM_ENGINE_OFF"; 713 case TAG_LAYER_PROPAGATION_OFF: return L"LAYER_PROPAGATION_OFF"; 714 case TAG_REINSTALL_UPGRADE: return L"REINSTALL_UPGRADE"; 715 716 /* TAG_TYPE_WORD */ 717 case TAG_MATCH_MODE: return L"MATCH_MODE"; 718 case TAG_TAG: return L"TAG"; 719 case TAG_INDEX_TAG: return L"INDEX_TAG"; 720 case TAG_INDEX_KEY: return L"INDEX_KEY"; 721 722 /* TAG_TYPE_DWORD */ 723 case TAG_SIZE: return L"SIZE"; 724 case TAG_OFFSET: return L"OFFSET"; 725 case TAG_CHECKSUM: return L"CHECKSUM"; 726 case TAG_SHIM_TAGID: return L"SHIM_TAGID"; 727 case TAG_PATCH_TAGID: return L"PATCH_TAGID"; 728 case TAG_MODULE_TYPE: return L"MODULE_TYPE"; 729 case TAG_VERDATEHI: return L"VERDATEHI"; 730 case TAG_VERDATELO: return L"VERDATELO"; 731 case TAG_VERFILEOS: return L"VERFILEOS"; 732 case TAG_VERFILETYPE: return L"VERFILETYPE"; 733 case TAG_PE_CHECKSUM: return L"PE_CHECKSUM"; 734 case TAG_PREVOSMAJORVER: return L"PREVOSMAJORVER"; 735 case TAG_PREVOSMINORVER: return L"PREVOSMINORVER"; 736 case TAG_PREVOSPLATFORMID: return L"PREVOSPLATFORMID"; 737 case TAG_PREVOSBUILDNO: return L"PREVOSBUILDNO"; 738 case TAG_PROBLEMSEVERITY: return L"PROBLEMSEVERITY"; 739 case TAG_LANGID: return L"LANGID"; 740 case TAG_VER_LANGUAGE: return L"VER_LANGUAGE"; 741 case TAG_ENGINE: return L"ENGINE"; 742 case TAG_HTMLHELPID: return L"HTMLHELPID"; 743 case TAG_INDEX_FLAGS: return L"INDEX_FLAGS"; 744 case TAG_FLAGS: return L"FLAGS"; 745 case TAG_DATA_VALUETYPE: return L"DATA_VALUETYPE"; 746 case TAG_DATA_DWORD: return L"DATA_DWORD"; 747 case TAG_LAYER_TAGID: return L"LAYER_TAGID"; 748 case TAG_MSI_TRANSFORM_TAGID: return L"MSI_TRANSFORM_TAGID"; 749 case TAG_LINKER_VERSION: return L"LINKER_VERSION"; 750 case TAG_LINK_DATE: return L"LINK_DATE"; 751 case TAG_UPTO_LINK_DATE: return L"UPTO_LINK_DATE"; 752 case TAG_OS_SERVICE_PACK: return L"OS_SERVICE_PACK"; 753 case TAG_FLAG_TAGID: return L"FLAG_TAGID"; 754 case TAG_RUNTIME_PLATFORM: return L"RUNTIME_PLATFORM"; 755 case TAG_OS_SKU: return L"OS_SKU"; 756 case TAG_OS_PLATFORM: return L"OS_PLATFORM"; 757 case TAG_APP_NAME_RC_ID: return L"APP_NAME_RC_ID"; 758 case TAG_VENDOR_NAME_RC_ID: return L"VENDOR_NAME_RC_ID"; 759 case TAG_SUMMARY_MSG_RC_ID: return L"SUMMARY_MSG_RC_ID"; 760 case TAG_VISTA_SKU: return L"VISTA_SKU"; 761 case TAG_DESCRIPTION_RC_ID: return L"DESCRIPTION_RC_ID"; 762 case TAG_PARAMETER1_RC_ID: return L"PARAMETER1_RC_ID"; 763 case TAG_CONTEXT_TAGID: return L"CONTEXT_TAGID"; 764 case TAG_EXE_WRAPPER: return L"EXE_WRAPPER"; 765 case TAG_URL_ID: return L"URL_ID"; 766 case TAG_TAGID: return L"TAGID"; 767 768 /* TAG_TYPE_QWORD */ 769 case TAG_TIME: return L"TIME"; 770 case TAG_BIN_FILE_VERSION: return L"BIN_FILE_VERSION"; 771 case TAG_BIN_PRODUCT_VERSION: return L"BIN_PRODUCT_VERSION"; 772 case TAG_MODTIME: return L"MODTIME"; 773 case TAG_FLAG_MASK_KERNEL: return L"FLAG_MASK_KERNEL"; 774 case TAG_UPTO_BIN_PRODUCT_VERSION: return L"UPTO_BIN_PRODUCT_VERSION"; 775 case TAG_DATA_QWORD: return L"DATA_QWORD"; 776 case TAG_FLAG_MASK_USER: return L"FLAG_MASK_USER"; 777 case TAG_FLAGS_NTVDM1: return L"FLAGS_NTVDM1"; 778 case TAG_FLAGS_NTVDM2: return L"FLAGS_NTVDM2"; 779 case TAG_FLAGS_NTVDM3: return L"FLAGS_NTVDM3"; 780 case TAG_FLAG_MASK_SHELL: return L"FLAG_MASK_SHELL"; 781 case TAG_UPTO_BIN_FILE_VERSION: return L"UPTO_BIN_FILE_VERSION"; 782 case TAG_FLAG_MASK_FUSION: return L"FLAG_MASK_FUSION"; 783 case TAG_FLAG_PROCESSPARAM: return L"FLAG_PROCESSPARAM"; 784 case TAG_FLAG_LUA: return L"FLAG_LUA"; 785 case TAG_FLAG_INSTALL: return L"FLAG_INSTALL"; 786 787 /* TAG_TYPE_STRINGREF */ 788 case TAG_NAME: return L"NAME"; 789 case TAG_DESCRIPTION: return L"DESCRIPTION"; 790 case TAG_MODULE: return L"MODULE"; 791 case TAG_API: return L"API"; 792 case TAG_VENDOR: return L"VENDOR"; 793 case TAG_APP_NAME: return L"APP_NAME"; 794 case TAG_COMMAND_LINE: return L"COMMAND_LINE"; 795 case TAG_COMPANY_NAME: return L"COMPANY_NAME"; 796 case TAG_DLLFILE: return L"DLLFILE"; 797 case TAG_WILDCARD_NAME: return L"WILDCARD_NAME"; 798 case TAG_PRODUCT_NAME: return L"PRODUCT_NAME"; 799 case TAG_PRODUCT_VERSION: return L"PRODUCT_VERSION"; 800 case TAG_FILE_DESCRIPTION: return L"FILE_DESCRIPTION"; 801 case TAG_FILE_VERSION: return L"FILE_VERSION"; 802 case TAG_ORIGINAL_FILENAME: return L"ORIGINAL_FILENAME"; 803 case TAG_INTERNAL_NAME: return L"INTERNAL_NAME"; 804 case TAG_LEGAL_COPYRIGHT: return L"LEGAL_COPYRIGHT"; 805 case TAG_16BIT_DESCRIPTION: return L"16BIT_DESCRIPTION"; 806 case TAG_APPHELP_DETAILS: return L"APPHELP_DETAILS"; 807 case TAG_LINK_URL: return L"LINK_URL"; 808 case TAG_LINK_TEXT: return L"LINK_TEXT"; 809 case TAG_APPHELP_TITLE: return L"APPHELP_TITLE"; 810 case TAG_APPHELP_CONTACT: return L"APPHELP_CONTACT"; 811 case TAG_SXS_MANIFEST: return L"SXS_MANIFEST"; 812 case TAG_DATA_STRING: return L"DATA_STRING"; 813 case TAG_MSI_TRANSFORM_FILE: return L"MSI_TRANSFORM_FILE"; 814 case TAG_16BIT_MODULE_NAME: return L"16BIT_MODULE_NAME"; 815 case TAG_LAYER_DISPLAYNAME: return L"LAYER_DISPLAYNAME"; 816 case TAG_COMPILER_VERSION: return L"COMPILER_VERSION"; 817 case TAG_ACTION_TYPE: return L"ACTION_TYPE"; 818 case TAG_EXPORT_NAME: return L"EXPORT_NAME"; 819 case TAG_URL: return L"URL"; 820 821 /* TAG_TYPE_LIST */ 822 case TAG_DATABASE: return L"DATABASE"; 823 case TAG_LIBRARY: return L"LIBRARY"; 824 case TAG_INEXCLUD: return L"INEXCLUDE"; 825 case TAG_SHIM: return L"SHIM"; 826 case TAG_PATCH: return L"PATCH"; 827 case TAG_APP: return L"APP"; 828 case TAG_EXE: return L"EXE"; 829 case TAG_MATCHING_FILE: return L"MATCHING_FILE"; 830 case TAG_SHIM_REF: return L"SHIM_REF"; 831 case TAG_PATCH_REF: return L"PATCH_REF"; 832 case TAG_LAYER: return L"LAYER"; 833 case TAG_FILE: return L"FILE"; 834 case TAG_APPHELP: return L"APPHELP"; 835 case TAG_LINK: return L"LINK"; 836 case TAG_DATA: return L"DATA"; 837 case TAG_MSI_TRANSFORM: return L"MSI_TRANSFORM"; 838 case TAG_MSI_TRANSFORM_REF: return L"MSI_TRANSFORM_REF"; 839 case TAG_MSI_PACKAGE: return L"MSI_PACKAGE"; 840 case TAG_FLAG: return L"FLAG"; 841 case TAG_MSI_CUSTOM_ACTION: return L"MSI_CUSTOM_ACTION"; 842 case TAG_FLAG_REF: return L"FLAG_REF"; 843 case TAG_ACTION: return L"ACTION"; 844 case TAG_LOOKUP: return L"LOOKUP"; 845 case TAG_CONTEXT: return L"CONTEXT"; 846 case TAG_CONTEXT_REF: return L"CONTEXT_REF"; 847 case TAG_SPC: return L"SPC"; 848 case TAG_STRINGTABLE: return L"STRINGTABLE"; 849 case TAG_INDEXES: return L"INDEXES"; 850 case TAG_INDEX: return L"INDEX"; 851 852 /* TAG_TYPE_STRING */ 853 case TAG_STRINGTABLE_ITEM: return L"STRINGTABLE_ITEM"; 854 855 /* TAG_TYPE_BINARY */ 856 case TAG_PATCH_BITS: return L"PATCH_BITS"; 857 case TAG_FILE_BITS: return L"FILE_BITS"; 858 case TAG_EXE_ID: return L"EXE_ID"; 859 case TAG_DATA_BITS: return L"DATA_BITS"; 860 case TAG_MSI_PACKAGE_ID: return L"MSI_PACKAGE_ID"; 861 case TAG_DATABASE_ID: return L"DATABASE_ID"; 862 case TAG_CONTEXT_PLATFORM_ID: return L"CONTEXT_PLATFORM_ID"; 863 case TAG_CONTEXT_BRANCH_ID: return L"CONTEXT_BRANCH_ID"; 864 case TAG_FIX_ID: return L"FIX_ID"; 865 case TAG_APP_ID: return L"APP_ID"; 866 case TAG_INDEX_BITS: return L"INDEX_BITS"; 867 868 break; 869 } 870 return L"InvalidTag"; 871 } 872