reactos/dll/appcompat/apphelp/sdbapi.c

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