dll/appcompat/apphelp/sdbapi.c

   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-2017 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]  database    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 /**
 538  * Converts the specified string to an index key.
 539  *
 540  * @param [in]  str The string which will be converted.
 541  *
 542  * @return  The resulting index key
 543  *
 544  * @todo: Fix this for unicode strings.
 545  */
 546 LONGLONG WINAPI SdbMakeIndexKeyFromString(LPCWSTR str)
 547 {
 548     LONGLONG result = 0;
 549     int shift = 56;
 550
 551     while (*str && shift >= 0)
 552     {
 553         WCHAR c = toupper(*(str++));
 554
 555         if (c & 0xff)
 556         {
 557             result |= (((LONGLONG)(c & 0xff)) << shift);
 558             shift -= 8;
 559         }
 560
 561         if (shift < 0)
 562             break;
 563
 564         c >>= 8;
 565
 566         if (c & 0xff)
 567         {
 568             result |= (((LONGLONG)(c & 0xff)) << shift);
 569             shift -= 8;
 570         }
 571     }
 572
 573     return result;
 574 }
 575
 576
 577 /**
 578  * Converts specified tag into a string.
 579  *
 580  * @param [in]  tag The tag which will be converted to a string.
 581  *
 582  * @return  Success: Pointer to the string matching specified tag, or L"InvalidTag" on failure.
 583  *
 584  */
 585 LPCWSTR WINAPI SdbTagToString(TAG tag)
 586 {
 587     switch (tag)
 588     {
 589     case TAG_NULL: return L"NULL";
 590
 591     /* TAG_TYPE_NULL */
 592     case TAG_INCLUDE: return L"INCLUDE";
 593     case TAG_GENERAL: return L"GENERAL";
 594     case TAG_MATCH_LOGIC_NOT: return L"MATCH_LOGIC_NOT";
 595     case TAG_APPLY_ALL_SHIMS: return L"APPLY_ALL_SHIMS";
 596     case TAG_USE_SERVICE_PACK_FILES: return L"USE_SERVICE_PACK_FILES";
 597     case TAG_MITIGATION_OS: return L"MITIGATION_OS";
 598     case TAG_BLOCK_UPGRADE: return L"BLOCK_UPGRADE";
 599     case TAG_INCLUDEEXCLUDEDLL: return L"INCLUDEEXCLUDEDLL";
 600     case TAG_RAC_EVENT_OFF: return L"RAC_EVENT_OFF";
 601     case TAG_TELEMETRY_OFF: return L"TELEMETRY_OFF";
 602     case TAG_SHIM_ENGINE_OFF: return L"SHIM_ENGINE_OFF";
 603     case TAG_LAYER_PROPAGATION_OFF: return L"LAYER_PROPAGATION_OFF";
 604     case TAG_REINSTALL_UPGRADE: return L"REINSTALL_UPGRADE";
 605
 606     /* TAG_TYPE_WORD */
 607     case TAG_MATCH_MODE: return L"MATCH_MODE";
 608     case TAG_TAG: return L"TAG";
 609     case TAG_INDEX_TAG: return L"INDEX_TAG";
 610     case TAG_INDEX_KEY: return L"INDEX_KEY";
 611
 612     /* TAG_TYPE_DWORD */
 613     case TAG_SIZE: return L"SIZE";
 614     case TAG_OFFSET: return L"OFFSET";
 615     case TAG_CHECKSUM: return L"CHECKSUM";
 616     case TAG_SHIM_TAGID: return L"SHIM_TAGID";
 617     case TAG_PATCH_TAGID: return L"PATCH_TAGID";
 618     case TAG_MODULE_TYPE: return L"MODULE_TYPE";
 619     case TAG_VERDATEHI: return L"VERDATEHI";
 620     case TAG_VERDATELO: return L"VERDATELO";
 621     case TAG_VERFILEOS: return L"VERFILEOS";
 622     case TAG_VERFILETYPE: return L"VERFILETYPE";
 623     case TAG_PE_CHECKSUM: return L"PE_CHECKSUM";
 624     case TAG_PREVOSMAJORVER: return L"PREVOSMAJORVER";
 625     case TAG_PREVOSMINORVER: return L"PREVOSMINORVER";
 626     case TAG_PREVOSPLATFORMID: return L"PREVOSPLATFORMID";
 627     case TAG_PREVOSBUILDNO: return L"PREVOSBUILDNO";
 628     case TAG_PROBLEMSEVERITY: return L"PROBLEMSEVERITY";
 629     case TAG_LANGID: return L"LANGID";
 630     case TAG_VER_LANGUAGE: return L"VER_LANGUAGE";
 631     case TAG_ENGINE: return L"ENGINE";
 632     case TAG_HTMLHELPID: return L"HTMLHELPID";
 633     case TAG_INDEX_FLAGS: return L"INDEX_FLAGS";
 634     case TAG_FLAGS: return L"FLAGS";
 635     case TAG_DATA_VALUETYPE: return L"DATA_VALUETYPE";
 636     case TAG_DATA_DWORD: return L"DATA_DWORD";
 637     case TAG_LAYER_TAGID: return L"LAYER_TAGID";
 638     case TAG_MSI_TRANSFORM_TAGID: return L"MSI_TRANSFORM_TAGID";
 639     case TAG_LINKER_VERSION: return L"LINKER_VERSION";
 640     case TAG_LINK_DATE: return L"LINK_DATE";
 641     case TAG_UPTO_LINK_DATE: return L"UPTO_LINK_DATE";
 642     case TAG_OS_SERVICE_PACK: return L"OS_SERVICE_PACK";
 643     case TAG_FLAG_TAGID: return L"FLAG_TAGID";
 644     case TAG_RUNTIME_PLATFORM: return L"RUNTIME_PLATFORM";
 645     case TAG_OS_SKU: return L"OS_SKU";
 646     case TAG_OS_PLATFORM: return L"OS_PLATFORM";
 647     case TAG_APP_NAME_RC_ID: return L"APP_NAME_RC_ID";
 648     case TAG_VENDOR_NAME_RC_ID: return L"VENDOR_NAME_RC_ID";
 649     case TAG_SUMMARY_MSG_RC_ID: return L"SUMMARY_MSG_RC_ID";
 650     case TAG_VISTA_SKU: return L"VISTA_SKU";
 651     case TAG_DESCRIPTION_RC_ID: return L"DESCRIPTION_RC_ID";
 652     case TAG_PARAMETER1_RC_ID: return L"PARAMETER1_RC_ID";
 653     case TAG_CONTEXT_TAGID: return L"CONTEXT_TAGID";
 654     case TAG_EXE_WRAPPER: return L"EXE_WRAPPER";
 655     case TAG_URL_ID: return L"URL_ID";
 656     case TAG_TAGID: return L"TAGID";
 657
 658     /* TAG_TYPE_QWORD */
 659     case TAG_TIME: return L"TIME";
 660     case TAG_BIN_FILE_VERSION: return L"BIN_FILE_VERSION";
 661     case TAG_BIN_PRODUCT_VERSION: return L"BIN_PRODUCT_VERSION";
 662     case TAG_MODTIME: return L"MODTIME";
 663     case TAG_FLAG_MASK_KERNEL: return L"FLAG_MASK_KERNEL";
 664     case TAG_UPTO_BIN_PRODUCT_VERSION: return L"UPTO_BIN_PRODUCT_VERSION";
 665     case TAG_DATA_QWORD: return L"DATA_QWORD";
 666     case TAG_FLAG_MASK_USER: return L"FLAG_MASK_USER";
 667     case TAG_FLAGS_NTVDM1: return L"FLAGS_NTVDM1";
 668     case TAG_FLAGS_NTVDM2: return L"FLAGS_NTVDM2";
 669     case TAG_FLAGS_NTVDM3: return L"FLAGS_NTVDM3";
 670     case TAG_FLAG_MASK_SHELL: return L"FLAG_MASK_SHELL";
 671     case TAG_UPTO_BIN_FILE_VERSION: return L"UPTO_BIN_FILE_VERSION";
 672     case TAG_FLAG_MASK_FUSION: return L"FLAG_MASK_FUSION";
 673     case TAG_FLAG_PROCESSPARAM: return L"FLAG_PROCESSPARAM";
 674     case TAG_FLAG_LUA: return L"FLAG_LUA";
 675     case TAG_FLAG_INSTALL: return L"FLAG_INSTALL";
 676
 677     /* TAG_TYPE_STRINGREF */
 678     case TAG_NAME: return L"NAME";
 679     case TAG_DESCRIPTION: return L"DESCRIPTION";
 680     case TAG_MODULE: return L"MODULE";
 681     case TAG_API: return L"API";
 682     case TAG_VENDOR: return L"VENDOR";
 683     case TAG_APP_NAME: return L"APP_NAME";
 684     case TAG_COMMAND_LINE: return L"COMMAND_LINE";
 685     case TAG_COMPANY_NAME: return L"COMPANY_NAME";
 686     case TAG_DLLFILE: return L"DLLFILE";
 687     case TAG_WILDCARD_NAME: return L"WILDCARD_NAME";
 688     case TAG_PRODUCT_NAME: return L"PRODUCT_NAME";
 689     case TAG_PRODUCT_VERSION: return L"PRODUCT_VERSION";
 690     case TAG_FILE_DESCRIPTION: return L"FILE_DESCRIPTION";
 691     case TAG_FILE_VERSION: return L"FILE_VERSION";
 692     case TAG_ORIGINAL_FILENAME: return L"ORIGINAL_FILENAME";
 693     case TAG_INTERNAL_NAME: return L"INTERNAL_NAME";
 694     case TAG_LEGAL_COPYRIGHT: return L"LEGAL_COPYRIGHT";
 695     case TAG_16BIT_DESCRIPTION: return L"16BIT_DESCRIPTION";
 696     case TAG_APPHELP_DETAILS: return L"APPHELP_DETAILS";
 697     case TAG_LINK_URL: return L"LINK_URL";
 698     case TAG_LINK_TEXT: return L"LINK_TEXT";
 699     case TAG_APPHELP_TITLE: return L"APPHELP_TITLE";
 700     case TAG_APPHELP_CONTACT: return L"APPHELP_CONTACT";
 701     case TAG_SXS_MANIFEST: return L"SXS_MANIFEST";
 702     case TAG_DATA_STRING: return L"DATA_STRING";
 703     case TAG_MSI_TRANSFORM_FILE: return L"MSI_TRANSFORM_FILE";
 704     case TAG_16BIT_MODULE_NAME: return L"16BIT_MODULE_NAME";
 705     case TAG_LAYER_DISPLAYNAME: return L"LAYER_DISPLAYNAME";
 706     case TAG_COMPILER_VERSION: return L"COMPILER_VERSION";
 707     case TAG_ACTION_TYPE: return L"ACTION_TYPE";
 708     case TAG_EXPORT_NAME: return L"EXPORT_NAME";
 709     case TAG_URL: return L"URL";
 710
 711     /* TAG_TYPE_LIST */
 712     case TAG_DATABASE: return L"DATABASE";
 713     case TAG_LIBRARY: return L"LIBRARY";
 714     case TAG_INEXCLUD: return L"INEXCLUDE";
 715     case TAG_SHIM: return L"SHIM";
 716     case TAG_PATCH: return L"PATCH";
 717     case TAG_APP: return L"APP";
 718     case TAG_EXE: return L"EXE";
 719     case TAG_MATCHING_FILE: return L"MATCHING_FILE";
 720     case TAG_SHIM_REF: return L"SHIM_REF";
 721     case TAG_PATCH_REF: return L"PATCH_REF";
 722     case TAG_LAYER: return L"LAYER";
 723     case TAG_FILE: return L"FILE";
 724     case TAG_APPHELP: return L"APPHELP";
 725     case TAG_LINK: return L"LINK";
 726     case TAG_DATA: return L"DATA";
 727     case TAG_MSI_TRANSFORM: return L"MSI_TRANSFORM";
 728     case TAG_MSI_TRANSFORM_REF: return L"MSI_TRANSFORM_REF";
 729     case TAG_MSI_PACKAGE: return L"MSI_PACKAGE";
 730     case TAG_FLAG: return L"FLAG";
 731     case TAG_MSI_CUSTOM_ACTION: return L"MSI_CUSTOM_ACTION";
 732     case TAG_FLAG_REF: return L"FLAG_REF";
 733     case TAG_ACTION: return L"ACTION";
 734     case TAG_LOOKUP: return L"LOOKUP";
 735     case TAG_CONTEXT: return L"CONTEXT";
 736     case TAG_CONTEXT_REF: return L"CONTEXT_REF";
 737     case TAG_SPC: return L"SPC";
 738     case TAG_STRINGTABLE: return L"STRINGTABLE";
 739     case TAG_INDEXES: return L"INDEXES";
 740     case TAG_INDEX: return L"INDEX";
 741
 742     /* TAG_TYPE_STRING */
 743     case TAG_STRINGTABLE_ITEM: return L"STRINGTABLE_ITEM";
 744
 745     /* TAG_TYPE_BINARY */
 746     case TAG_PATCH_BITS: return L"PATCH_BITS";
 747     case TAG_FILE_BITS: return L"FILE_BITS";
 748     case TAG_EXE_ID: return L"EXE_ID";
 749     case TAG_DATA_BITS: return L"DATA_BITS";
 750     case TAG_MSI_PACKAGE_ID: return L"MSI_PACKAGE_ID";
 751     case TAG_DATABASE_ID: return L"DATABASE_ID";
 752     case TAG_CONTEXT_PLATFORM_ID: return L"CONTEXT_PLATFORM_ID";
 753     case TAG_CONTEXT_BRANCH_ID: return L"CONTEXT_BRANCH_ID";
 754     case TAG_FIX_ID: return L"FIX_ID";
 755     case TAG_APP_ID: return L"APP_ID";
 756     case TAG_INDEX_BITS: return L"INDEX_BITS";
 757
 758         break;
 759     }
 760     return L"InvalidTag";
 761 }