reactos/dll/appcompat/apphelp/sdbapi.c

   1 /*
   2  * Copyright 2011 André Hentschel
   3  * Copyright 2013 Mislav Blažević
   4  * Copyright 2015,2016 Mark Jansen
   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 #define WIN32_NO_STATUS
  22 #include "windows.h"
  23 #include "ntndk.h"
  24 #include "strsafe.h"
  25 #include "apphelp.h"
  26
  27 #include "wine/unicode.h"
  28
  29
  30 static const GUID GUID_DATABASE_MSI = {0xd8ff6d16,0x6a3a,0x468a, {0x8b,0x44,0x01,0x71,0x4d,0xdc,0x49,0xea}};
  31 static const GUID GUID_DATABASE_SHIM = {0x11111111,0x1111,0x1111, {0x11,0x11,0x11,0x11,0x11,0x11,0x11,0x11}};
  32 static const GUID GUID_DATABASE_DRIVERS = {0xf9ab2228,0x3312,0x4a73, {0xb6,0xf9,0x93,0x6d,0x70,0xe1,0x12,0xef}};
  33
  34 static HANDLE SdbpHeap(void);
  35
  36 #if SDBAPI_DEBUG_ALLOC
  37
  38 typedef struct SHIM_ALLOC_ENTRY
  39 {
  40     PVOID Address;
  41     SIZE_T Size;
  42     int Line;
  43     const char* File;
  44     PVOID Next;
  45     PVOID Prev;
  46 } SHIM_ALLOC_ENTRY, *PSHIM_ALLOC_ENTRY;
  47
  48
  49 static RTL_AVL_TABLE g_SdbpAllocationTable;
  50
  51
  52 static RTL_GENERIC_COMPARE_RESULTS
  53 NTAPI ShimAllocCompareRoutine(_In_ PRTL_AVL_TABLE Table, _In_ PVOID FirstStruct, _In_ PVOID SecondStruct)
  54 {
  55     PVOID First = ((PSHIM_ALLOC_ENTRY)FirstStruct)->Address;
  56     PVOID Second = ((PSHIM_ALLOC_ENTRY)SecondStruct)->Address;
  57
  58     if (First < Second)
  59         return GenericLessThan;
  60     else if (First == Second)
  61         return GenericEqual;
  62     return GenericGreaterThan;
  63 }
  64
  65 static PVOID NTAPI ShimAllocAllocateRoutine(_In_ PRTL_AVL_TABLE Table, _In_ CLONG ByteSize)
  66 {
  67     return HeapAlloc(SdbpHeap(), HEAP_ZERO_MEMORY, ByteSize);
  68 }
  69
  70 static VOID NTAPI ShimAllocFreeRoutine(_In_ PRTL_AVL_TABLE Table, _In_ PVOID Buffer)
  71 {
  72     HeapFree(SdbpHeap(), 0, Buffer);
  73 }
  74
  75 static void SdbpInsertAllocation(PVOID address, SIZE_T size, int line, const char* file)
  76 {
  77     SHIM_ALLOC_ENTRY Entry = {0};
  78
  79     Entry.Address = address;
  80     Entry.Size = size;
  81     Entry.Line = line;
  82     Entry.File = file;
  83     RtlInsertElementGenericTableAvl(&g_SdbpAllocationTable, &Entry, sizeof(Entry), NULL);
  84 }
  85
  86 static void SdbpUpdateAllocation(PVOID address, PVOID newaddress, SIZE_T size, int line, const char* file)
  87 {
  88     SHIM_ALLOC_ENTRY Lookup = {0};
  89     PSHIM_ALLOC_ENTRY Entry;
  90     Lookup.Address = address;
  91     Entry = RtlLookupElementGenericTableAvl(&g_SdbpAllocationTable, &Lookup);
  92
  93     if (address == newaddress)
  94     {
  95         Entry->Size = size;
  96     }
  97     else
  98     {
  99         Lookup.Address = newaddress;
 100         Lookup.Size = size;
 101         Lookup.Line = line;
 102         Lookup.File = file;
 103         Lookup.Prev = address;
 104         RtlInsertElementGenericTableAvl(&g_SdbpAllocationTable, &Lookup, sizeof(Lookup), NULL);
 105         Entry->Next = newaddress;
 106     }
 107 }
 108
 109 static void SdbpRemoveAllocation(PVOID address, int line, const char* file)
 110 {
 111     char buf[512];
 112     SHIM_ALLOC_ENTRY Lookup = {0};
 113     PSHIM_ALLOC_ENTRY Entry;
 114
 115     sprintf(buf, "\r\n===============\r\n%s(%d): SdbpFree called, tracing alloc:\r\n", file, line);
 116     OutputDebugStringA(buf);
 117
 118     Lookup.Address = address;
 119     while (Lookup.Address)
 120     {
 121         Entry = RtlLookupElementGenericTableAvl(&g_SdbpAllocationTable, &Lookup);
 122         if (Entry)
 123         {
 124             Lookup = *Entry;
 125             RtlDeleteElementGenericTableAvl(&g_SdbpAllocationTable, Entry);
 126
 127             sprintf(buf, " > %s(%d): %s%sAlloc( %d ) ==> %p\r\n", Lookup.File, Lookup.Line,
 128                 Lookup.Next ? "Invalidated " : "", Lookup.Prev ? "Re" : "", Lookup.Size, Lookup.Address);
 129             OutputDebugStringA(buf);
 130             Lookup.Address = Lookup.Prev;
 131         }
 132         else
 133         {
 134             Lookup.Address = NULL;
 135         }
 136     }
 137     sprintf(buf, "\r\n===============\r\n");
 138     OutputDebugStringA(buf);
 139 }
 140
 141 #endif
 142
 143 static HANDLE g_Heap;
 144 void SdbpHeapInit(void)
 145 {
 146 #if SDBAPI_DEBUG_ALLOC
 147     RtlInitializeGenericTableAvl(&g_SdbpAllocationTable, ShimAllocCompareRoutine,
 148         ShimAllocAllocateRoutine, ShimAllocFreeRoutine, NULL);
 149 #endif
 150     g_Heap = HeapCreate(0, 0x10000, 0);
 151 }
 152
 153 void SdbpHeapDeinit(void)
 154 {
 155 #if SDBAPI_DEBUG_ALLOC
 156     if (g_SdbpAllocationTable.NumberGenericTableElements != 0)
 157         __debugbreak();
 158 #endif
 159     HeapDestroy(g_Heap);
 160 }
 161
 162 static HANDLE SdbpHeap(void)
 163 {
 164     return g_Heap;
 165 }
 166
 167 LPVOID SdbpAlloc(SIZE_T size
 168 #if SDBAPI_DEBUG_ALLOC
 169     , int line, const char* file
 170 #endif
 171     )
 172 {
 173     LPVOID mem = HeapAlloc(SdbpHeap(), HEAP_ZERO_MEMORY, size);
 174 #if SDBAPI_DEBUG_ALLOC
 175     SdbpInsertAllocation(mem, size, line, file);
 176 #endif
 177     return mem;
 178 }
 179
 180 LPVOID SdbpReAlloc(LPVOID mem, SIZE_T size
 181 #if SDBAPI_DEBUG_ALLOC
 182     , int line, const char* file
 183 #endif
 184     )
 185 {
 186     LPVOID newmem = HeapReAlloc(SdbpHeap(), HEAP_ZERO_MEMORY, mem, size);
 187 #if SDBAPI_DEBUG_ALLOC
 188     SdbpUpdateAllocation(mem, newmem, size, line, file);
 189 #endif
 190     return newmem;
 191 }
 192
 193 void SdbpFree(LPVOID mem
 194 #if SDBAPI_DEBUG_ALLOC
 195     , int line, const char* file
 196 #endif
 197     )
 198 {
 199 #if SDBAPI_DEBUG_ALLOC
 200     SdbpRemoveAllocation(mem, line, file);
 201 #endif
 202     HeapFree(SdbpHeap(), 0, mem);
 203 }
 204
 205 PDB WINAPI SdbpCreate(void)
 206 {
 207     PDB db = (PDB)SdbAlloc(sizeof(DB));
 208     /* SdbAlloc zeroes the memory. */
 209     return db;
 210 }
 211 DWORD SdbpStrlen(PCWSTR string)
 212 {
 213     return (lstrlenW(string) + 1) * sizeof(WCHAR);
 214 }
 215
 216 PWSTR SdbpStrDup(LPCWSTR string)
 217 {
 218     PWSTR ret = SdbpAlloc(SdbpStrlen(string));
 219     lstrcpyW(ret, string);
 220     return ret;
 221 }
 222
 223
 224 BOOL WINAPI SdbpOpenMemMappedFile(LPCWSTR path, PMEMMAPPED mapping)
 225 {
 226     NTSTATUS Status;
 227     OBJECT_ATTRIBUTES ObjectAttributes;
 228     IO_STATUS_BLOCK IoStatusBlock;
 229     FILE_STANDARD_INFORMATION FileStandard;
 230     UNICODE_STRING FileName;
 231
 232     RtlZeroMemory(mapping, sizeof(*mapping));
 233
 234     if(!RtlDosPathNameToNtPathName_U(path, &FileName, NULL, NULL))
 235     {
 236         RtlFreeUnicodeString(&FileName);
 237         return FALSE;
 238     }
 239
 240     InitializeObjectAttributes(&ObjectAttributes, &FileName, OBJ_CASE_INSENSITIVE, NULL, NULL);
 241     Status = NtOpenFile(&mapping->file, GENERIC_READ | SYNCHRONIZE, &ObjectAttributes, &IoStatusBlock, FILE_SHARE_READ, FILE_SYNCHRONOUS_IO_NONALERT);
 242     RtlFreeUnicodeString(&FileName);
 243
 244     if (!NT_SUCCESS(Status))
 245     {
 246         SHIM_ERR("Failed to open file %S: 0x%lx\n", path, Status);
 247         return FALSE;
 248     }
 249
 250     Status = NtCreateSection(&mapping->section, STANDARD_RIGHTS_REQUIRED | SECTION_QUERY | SECTION_MAP_READ, 0, 0, PAGE_READONLY, SEC_COMMIT, mapping->file);
 251     if (!NT_SUCCESS(Status))
 252     {
 253         /* Special case */
 254         if (Status == STATUS_MAPPED_FILE_SIZE_ZERO)
 255         {
 256             NtClose(mapping->file);
 257             mapping->file = mapping->section = NULL;
 258             return TRUE;
 259         }
 260         SHIM_ERR("Failed to create mapping for file: 0x%lx\n", Status);
 261         goto err_out;
 262     }
 263
 264     Status = NtQueryInformationFile(mapping->file, &IoStatusBlock, &FileStandard, sizeof(FileStandard), FileStandardInformation);
 265     if (!NT_SUCCESS(Status))
 266     {
 267         SHIM_ERR("Failed to read file info for file: 0x%lx\n", Status);
 268         goto err_out;
 269     }
 270
 271     mapping->mapped_size = mapping->size = FileStandard.EndOfFile.LowPart;
 272     Status = NtMapViewOfSection(mapping->section, NtCurrentProcess(), (PVOID*)&mapping->view, 0, 0, 0, &mapping->mapped_size, ViewUnmap, 0, PAGE_READONLY);
 273     if (!NT_SUCCESS(Status))
 274     {
 275         SHIM_ERR("Failed to map view of file: 0x%lx\n", Status);
 276         goto err_out;
 277     }
 278
 279     return TRUE;
 280
 281 err_out:
 282     if (!mapping->view)
 283     {
 284         if (mapping->section)
 285             NtClose(mapping->section);
 286         NtClose(mapping->file);
 287     }
 288     return FALSE;
 289 }
 290
 291 void WINAPI SdbpCloseMemMappedFile(PMEMMAPPED mapping)
 292 {
 293     /* Prevent a VAD warning */
 294     if (mapping->view)
 295         NtUnmapViewOfSection(NtCurrentProcess(), mapping->view);
 296     NtClose(mapping->section);
 297     NtClose(mapping->file);
 298     RtlZeroMemory(mapping, sizeof(*mapping));
 299 }
 300
 301 BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type)
 302 {
 303     if ((tag & TAG_TYPE_MASK) != type)
 304         return FALSE;
 305     return TRUE;
 306 }
 307
 308 BOOL WINAPI SdbpCheckTagIDType(PDB db, TAGID tagid, WORD type)
 309 {
 310     TAG tag = SdbGetTagFromTagID(db, tagid);
 311     if (tag == TAG_NULL)
 312         return FALSE;
 313     return SdbpCheckTagType(tag, type);
 314 }
 315
 316 PDB SdbpOpenDatabase(LPCWSTR path, PATH_TYPE type, PDWORD major, PDWORD minor)
 317 {
 318     UNICODE_STRING str;
 319     OBJECT_ATTRIBUTES attr;
 320     IO_STATUS_BLOCK io;
 321     PDB db;
 322     NTSTATUS Status;
 323     BYTE header[12];
 324
 325     if (type == DOS_PATH)
 326     {
 327         if (!RtlDosPathNameToNtPathName_U(path, &str, NULL, NULL))
 328             return NULL;
 329     }
 330     else
 331         RtlInitUnicodeString(&str, path);
 332
 333     db = SdbpCreate();
 334     if (!db)
 335     {
 336         SHIM_ERR("Failed to allocate memory for shim database\n");
 337         return NULL;
 338     }
 339
 340     InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, NULL, NULL);
 341
 342     Status = NtCreateFile(&db->file, FILE_GENERIC_READ | SYNCHRONIZE,
 343                           &attr, &io, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
 344                           FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
 345
 346     if (type == DOS_PATH)
 347         RtlFreeUnicodeString(&str);
 348
 349     if (!NT_SUCCESS(Status))
 350     {
 351         SdbCloseDatabase(db);
 352         SHIM_ERR("Failed to open shim database file: 0x%lx\n", Status);
 353         return NULL;
 354     }
 355
 356     db->size = GetFileSize(db->file, NULL);
 357     db->data = SdbAlloc(db->size);
 358     Status = NtReadFile(db->file, NULL, NULL, NULL, &io, db->data, db->size, NULL, NULL);
 359
 360     if (!NT_SUCCESS(Status))
 361     {
 362         SdbCloseDatabase(db);
 363         SHIM_ERR("Failed to open shim database file: 0x%lx\n", Status);
 364         return NULL;
 365     }
 366
 367     if (!SdbpReadData(db, &header, 0, 12))
 368     {
 369         SdbCloseDatabase(db);
 370         SHIM_ERR("Failed to read shim database header\n");
 371         return NULL;
 372     }
 373
 374     if (memcmp(&header[8], "sdbf", 4) != 0)
 375     {
 376         SdbCloseDatabase(db);
 377         SHIM_ERR("Shim database header is invalid\n");
 378         return NULL;
 379     }
 380
 381     *major = *(DWORD*)&header[0];
 382     *minor = *(DWORD*)&header[4];
 383
 384     return db;
 385 }
 386
 387
 388 /**
 389  * Opens specified shim database file.
 390  *
 391  * @param [in]  path    Path to the shim database.
 392  * @param [in]  type    Type of path. Either DOS_PATH or NT_PATH.
 393  *
 394  * @return  Success: Handle to the shim database, NULL otherwise.
 395  */
 396 PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type)
 397 {
 398     PDB db;
 399     DWORD major, minor;
 400
 401     db = SdbpOpenDatabase(path, type, &major, &minor);
 402     if (!db)
 403         return NULL;
 404
 405     if (major != 2)
 406     {
 407         SdbCloseDatabase(db);
 408         SHIM_ERR("Invalid shim database version\n");
 409         return NULL;
 410     }
 411
 412     db->stringtable = SdbFindFirstTag(db, TAGID_ROOT, TAG_STRINGTABLE);
 413     if(!SdbGetDatabaseID(db, &db->database_id))
 414     {
 415         SHIM_INFO("Failed to get the database id\n");
 416     }
 417     return db;
 418 }
 419
 420 /**
 421  * Closes specified database and frees its memory.
 422  *
 423  * @param [in]  db  Handle to the shim database.
 424  */
 425 void WINAPI SdbCloseDatabase(PDB db)
 426 {
 427     if (!db)
 428         return;
 429
 430     if (db->file)
 431         NtClose(db->file);
 432     SdbFree(db->data);
 433     SdbFree(db);
 434 }
 435
 436 /**
 437  * Retrieves AppPatch directory.
 438  *
 439  * @param [in]  db      Handle to the shim database.
 440  * @param [out] path    Pointer to memory in which path shall be written.
 441  * @param [in]  size    Size of the buffer in characters.
 442  */
 443 BOOL WINAPI SdbGetAppPatchDir(HSDB db, LPWSTR path, DWORD size)
 444 {
 445     static WCHAR* default_dir = NULL;
 446
 447     if(!default_dir)
 448     {
 449         WCHAR* tmp = NULL;
 450         UINT len = GetSystemWindowsDirectoryW(NULL, 0) + lstrlenW((CONST WCHAR[]){'\\','A','p','p','P','a','t','c','h',0});
 451         tmp = SdbAlloc((len + 1)* sizeof(WCHAR));
 452         if(tmp)
 453         {
 454             UINT r = GetSystemWindowsDirectoryW(tmp, len+1);
 455             if (r && r < len)
 456             {
 457                 if (SUCCEEDED(StringCchCatW(tmp, len+1, (CONST WCHAR[]){'\\','A','p','p','P','a','t','c','h',0})))
 458                 {
 459                     if(InterlockedCompareExchangePointer((void**)&default_dir, tmp, NULL) == NULL)
 460                         tmp = NULL;
 461                 }
 462             }
 463             if (tmp)
 464                 SdbFree(tmp);
 465         }
 466     }
 467
 468     /* In case function fails, path holds empty string */
 469     if (size > 0)
 470         *path = 0;
 471
 472     if (!db)
 473     {
 474         return SUCCEEDED(StringCchCopyW(path, size, default_dir));
 475     }
 476     else
 477     {
 478         /* fixme */
 479         return FALSE;
 480     }
 481 }
 482
 483 /**
 484  * Parses a string to retrieve a GUID.
 485  *
 486  * @param [in]  GuidString  The string to parse.
 487  * @param [out] Guid        The resulting GUID.
 488  *
 489  * @return  TRUE if it succeeds, FALSE if it fails.
 490  */
 491 BOOL WINAPI SdbGUIDFromString(PCWSTR GuidString, GUID *Guid)
 492 {
 493     UNICODE_STRING GuidString_u;
 494     RtlInitUnicodeString(&GuidString_u, GuidString);
 495     return NT_SUCCESS(RtlGUIDFromString(&GuidString_u, Guid));
 496 }
 497
 498 /**
 499  * Converts a GUID to a string.
 500  *
 501  * @param [in]  Guid        The GUID to convert.
 502  * @param [out] GuidString  The resulting string representation of Guid.
 503  * @param [in]  Length      The length of GuidString.
 504  *
 505  * @return  TRUE if it succeeds, FALSE if it fails.
 506  */
 507 BOOL WINAPI SdbGUIDToString(CONST GUID *Guid, PWSTR GuidString, SIZE_T Length)
 508 {
 509     UNICODE_STRING GuidString_u;
 510     if(NT_SUCCESS(RtlStringFromGUID(Guid, &GuidString_u)))
 511     {
 512         HRESULT hr = StringCchCopyNW(GuidString, Length, GuidString_u.Buffer, GuidString_u.Length / 2);
 513         RtlFreeUnicodeString(&GuidString_u);
 514         return SUCCEEDED(hr);
 515     }
 516     return FALSE;
 517 }
 518
 519 /**
 520  * Checks if the specified GUID is a NULL GUID
 521  *
 522  * @param [in]  Guid    The GUID to check.
 523  *
 524  * @return  TRUE if it is a NULL GUID.
 525  */
 526 BOOL WINAPI SdbIsNullGUID(CONST GUID *Guid)
 527 {
 528     static GUID NullGuid = { 0 };
 529     return !Guid || IsEqualGUID(&NullGuid, Guid);
 530 }
 531
 532 /**
 533  * Get the GUID from one of the standard databases.
 534  *
 535  * @param [in]  Flags   The ID to retrieve the guid from. (See SDB_DATABASE_MAIN_[xxx])
 536  * @param [out] Guid    The resulting GUID.
 537  *
 538  * @return  TRUE if a known database ID.
 539  */
 540 BOOL WINAPI SdbGetStandardDatabaseGUID(DWORD Flags, GUID* Guid)
 541 {
 542     const GUID* copy_from = NULL;
 543     switch(Flags & HID_DATABASE_TYPE_MASK)
 544     {
 545     case SDB_DATABASE_MAIN_MSI:
 546         copy_from = &GUID_DATABASE_MSI;
 547         break;
 548     case SDB_DATABASE_MAIN_SHIM:
 549         copy_from = &GUID_DATABASE_SHIM;
 550         break;
 551     case SDB_DATABASE_MAIN_DRIVERS:
 552         copy_from = &GUID_DATABASE_DRIVERS;
 553         break;
 554     default:
 555         SHIM_ERR("Cannot obtain database guid for databases other than main\n");
 556         return FALSE;
 557     }
 558     if(Guid)
 559     {
 560         memcpy(Guid, copy_from, sizeof(GUID));
 561     }
 562     return TRUE;
 563 }
 564
 565 /**
 566  * Read the database version from the specified database.
 567  *
 568  * @param [in]  database    The database.
 569  * @param [out] VersionHi   The first part of the version number.
 570  * @param [out] VersionLo   The second part of the version number.
 571  *
 572  * @return  TRUE if it succeeds or fails, FALSE if ???
 573  */
 574 BOOL WINAPI SdbGetDatabaseVersion(LPCWSTR database, PDWORD VersionHi, PDWORD VersionLo)
 575 {
 576     PDB db;
 577
 578     db = SdbpOpenDatabase(database, DOS_PATH, VersionHi, VersionLo);
 579     if (db)
 580         SdbCloseDatabase(db);
 581
 582     return TRUE;
 583 }
 584
 585 /**
 586  * Converts specified tag into a string.
 587  *
 588  * @param [in]  tag The tag which will be converted to a string.
 589  *
 590  * @return  Success: Pointer to the string matching specified tag, or L"InvalidTag" on failure.
 591  *
 592  * @todo: Convert this into a lookup table, this is wasting alot of space.
 593  */
 594 LPCWSTR WINAPI SdbTagToString(TAG tag)
 595 {
 596     /* lookup tables for tags in range 0x1 -> 0xFF | TYPE */
 597     static const WCHAR table[9][0x32][25] = {
 598     {   /* TAG_TYPE_NULL */
 599         {'I','N','C','L','U','D','E',0},
 600         {'G','E','N','E','R','A','L',0},
 601         {'M','A','T','C','H','_','L','O','G','I','C','_','N','O','T',0},
 602         {'A','P','P','L','Y','_','A','L','L','_','S','H','I','M','S',0},
 603         {'U','S','E','_','S','E','R','V','I','C','E','_','P','A','C','K','_','F','I','L','E','S',0},
 604         {'M','I','T','I','G','A','T','I','O','N','_','O','S',0},
 605         {'B','L','O','C','K','_','U','P','G','R','A','D','E',0},
 606         {'I','N','C','L','U','D','E','E','X','C','L','U','D','E','D','L','L',0},
 607         {'R','A','C','_','E','V','E','N','T','_','O','F','F',0},
 608         {'T','E','L','E','M','E','T','R','Y','_','O','F','F',0},
 609         {'S','H','I','M','_','E','N','G','I','N','E','_','O','F','F',0},
 610         {'L','A','Y','E','R','_','P','R','O','P','A','G','A','T','I','O','N','_','O','F','F',0},
 611         {'R','E','I','N','S','T','A','L','L','_','U','P','G','R','A','D','E',0}
 612     },
 613     {   /* TAG_TYPE_BYTE */
 614         {'I','n','v','a','l','i','d','T','a','g',0}
 615     },
 616     {   /* TAG_TYPE_WORD */
 617         {'M','A','T','C','H','_','M','O','D','E',0}
 618     },
 619     {   /* TAG_TYPE_DWORD */
 620         {'S','I','Z','E',0},
 621         {'O','F','F','S','E','T',0},
 622         {'C','H','E','C','K','S','U','M',0},
 623         {'S','H','I','M','_','T','A','G','I','D',0},
 624         {'P','A','T','C','H','_','T','A','G','I','D',0},
 625         {'M','O','D','U','L','E','_','T','Y','P','E',0},
 626         {'V','E','R','D','A','T','E','H','I',0},
 627         {'V','E','R','D','A','T','E','L','O',0},
 628         {'V','E','R','F','I','L','E','O','S',0},
 629         {'V','E','R','F','I','L','E','T','Y','P','E',0},
 630         {'P','E','_','C','H','E','C','K','S','U','M',0},
 631         {'P','R','E','V','O','S','M','A','J','O','R','V','E','R',0},
 632         {'P','R','E','V','O','S','M','I','N','O','R','V','E','R',0},
 633         {'P','R','E','V','O','S','P','L','A','T','F','O','R','M','I','D',0},
 634         {'P','R','E','V','O','S','B','U','I','L','D','N','O',0},
 635         {'P','R','O','B','L','E','M','S','E','V','E','R','I','T','Y',0},
 636         {'L','A','N','G','I','D',0},
 637         {'V','E','R','_','L','A','N','G','U','A','G','E',0},
 638         {'I','n','v','a','l','i','d','T','a','g',0},
 639         {'E','N','G','I','N','E',0},
 640         {'H','T','M','L','H','E','L','P','I','D',0},
 641         {'I','N','D','E','X','_','F','L','A','G','S',0},
 642         {'F','L','A','G','S',0},
 643         {'D','A','T','A','_','V','A','L','U','E','T','Y','P','E',0},
 644         {'D','A','T','A','_','D','W','O','R','D',0},
 645         {'L','A','Y','E','R','_','T','A','G','I','D',0},
 646         {'M','S','I','_','T','R','A','N','S','F','O','R','M','_','T','A','G','I','D',0},
 647         {'L','I','N','K','E','R','_','V','E','R','S','I','O','N',0},
 648         {'L','I','N','K','_','D','A','T','E',0},
 649         {'U','P','T','O','_','L','I','N','K','_','D','A','T','E',0},
 650         {'O','S','_','S','E','R','V','I','C','E','_','P','A','C','K',0},
 651         {'F','L','A','G','_','T','A','G','I','D',0},
 652         {'R','U','N','T','I','M','E','_','P','L','A','T','F','O','R','M',0},
 653         {'O','S','_','S','K','U',0},
 654         {'O','S','_','P','L','A','T','F','O','R','M',0},
 655         {'A','P','P','_','N','A','M','E','_','R','C','_','I','D',0},
 656         {'V','E','N','D','O','R','_','N','A','M','E','_','R','C','_','I','D',0},
 657         {'S','U','M','M','A','R','Y','_','M','S','G','_','R','C','_','I','D',0},
 658         {'V','I','S','T','A','_','S','K','U',0},
 659         {'D','E','S','C','R','I','P','T','I','O','N','_','R','C','_','I','D',0},
 660         {'P','A','R','A','M','E','T','E','R','1','_','R','C','_','I','D',0},
 661         {'I','n','v','a','l','i','d','T','a','g',0},
 662         {'I','n','v','a','l','i','d','T','a','g',0},
 663         {'I','n','v','a','l','i','d','T','a','g',0},
 664         {'I','n','v','a','l','i','d','T','a','g',0},
 665         {'I','n','v','a','l','i','d','T','a','g',0},
 666         {'I','n','v','a','l','i','d','T','a','g',0},
 667         {'C','O','N','T','E','X','T','_','T','A','G','I','D',0},
 668         {'E','X','E','_','W','R','A','P','P','E','R',0},
 669         {'U','R','L','_','I','D',0}
 670     },
 671     {   /* TAG_TYPE_QWORD */
 672         {'T','I','M','E',0},
 673         {'B','I','N','_','F','I','L','E','_','V','E','R','S','I','O','N',0},
 674         {'B','I','N','_','P','R','O','D','U','C','T','_','V','E','R','S','I','O','N',0},
 675         {'M','O','D','T','I','M','E',0},
 676         {'F','L','A','G','_','M','A','S','K','_','K','E','R','N','E','L',0},
 677         {'U','P','T','O','_','B','I','N','_','P','R','O','D','U','C','T','_','V','E','R','S','I','O','N',0},
 678         {'D','A','T','A','_','Q','W','O','R','D',0},
 679         {'F','L','A','G','_','M','A','S','K','_','U','S','E','R',0},
 680         {'F','L','A','G','S','_','N','T','V','D','M','1',0},
 681         {'F','L','A','G','S','_','N','T','V','D','M','2',0},
 682         {'F','L','A','G','S','_','N','T','V','D','M','3',0},
 683         {'F','L','A','G','_','M','A','S','K','_','S','H','E','L','L',0},
 684         {'U','P','T','O','_','B','I','N','_','F','I','L','E','_','V','E','R','S','I','O','N',0},
 685         {'F','L','A','G','_','M','A','S','K','_','F','U','S','I','O','N',0},
 686         {'F','L','A','G','_','P','R','O','C','E','S','S','P','A','R','A','M',0},
 687         {'F','L','A','G','_','L','U','A',0},
 688         {'F','L','A','G','_','I','N','S','T','A','L','L',0}
 689     },
 690     {   /* TAG_TYPE_STRINGREF */
 691         {'N','A','M','E',0},
 692         {'D','E','S','C','R','I','P','T','I','O','N',0},
 693         {'M','O','D','U','L','E',0},
 694         {'A','P','I',0},
 695         {'V','E','N','D','O','R',0},
 696         {'A','P','P','_','N','A','M','E',0},
 697         {'I','n','v','a','l','i','d','T','a','g',0},
 698         {'C','O','M','M','A','N','D','_','L','I','N','E',0},
 699         {'C','O','M','P','A','N','Y','_','N','A','M','E',0},
 700         {'D','L','L','F','I','L','E',0},
 701         {'W','I','L','D','C','A','R','D','_','N','A','M','E',0},
 702         {'I','n','v','a','l','i','d','T','a','g',0},
 703         {'I','n','v','a','l','i','d','T','a','g',0},
 704         {'I','n','v','a','l','i','d','T','a','g',0},
 705         {'I','n','v','a','l','i','d','T','a','g',0},
 706         {'P','R','O','D','U','C','T','_','N','A','M','E',0},
 707         {'P','R','O','D','U','C','T','_','V','E','R','S','I','O','N',0},
 708         {'F','I','L','E','_','D','E','S','C','R','I','P','T','I','O','N',0},
 709         {'F','I','L','E','_','V','E','R','S','I','O','N',0},
 710         {'O','R','I','G','I','N','A','L','_','F','I','L','E','N','A','M','E',0},
 711         {'I','N','T','E','R','N','A','L','_','N','A','M','E',0},
 712         {'L','E','G','A','L','_','C','O','P','Y','R','I','G','H','T',0},
 713         {'1','6','B','I','T','_','D','E','S','C','R','I','P','T','I','O','N',0},
 714         {'A','P','P','H','E','L','P','_','D','E','T','A','I','L','S',0},
 715         {'L','I','N','K','_','U','R','L',0},
 716         {'L','I','N','K','_','T','E','X','T',0},
 717         {'A','P','P','H','E','L','P','_','T','I','T','L','E',0},
 718         {'A','P','P','H','E','L','P','_','C','O','N','T','A','C','T',0},
 719         {'S','X','S','_','M','A','N','I','F','E','S','T',0},
 720         {'D','A','T','A','_','S','T','R','I','N','G',0},
 721         {'M','S','I','_','T','R','A','N','S','F','O','R','M','_','F','I','L','E',0},
 722         {'1','6','B','I','T','_','M','O','D','U','L','E','_','N','A','M','E',0},
 723         {'L','A','Y','E','R','_','D','I','S','P','L','A','Y','N','A','M','E',0},
 724         {'C','O','M','P','I','L','E','R','_','V','E','R','S','I','O','N',0},
 725         {'A','C','T','I','O','N','_','T','Y','P','E',0},
 726         {'E','X','P','O','R','T','_','N','A','M','E',0},
 727         {'U','R','L',0}
 728     },
 729     {   /* TAG_TYPE_LIST */
 730         {'D','A','T','A','B','A','S','E',0},
 731         {'L','I','B','R','A','R','Y',0},
 732         {'I','N','E','X','C','L','U','D','E',0},
 733         {'S','H','I','M',0},
 734         {'P','A','T','C','H',0},
 735         {'A','P','P',0},
 736         {'E','X','E',0},
 737         {'M','A','T','C','H','I','N','G','_','F','I','L','E',0},
 738         {'S','H','I','M','_','R','E','F',0},
 739         {'P','A','T','C','H','_','R','E','F',0},
 740         {'L','A','Y','E','R',0},
 741         {'F','I','L','E',0},
 742         {'A','P','P','H','E','L','P',0},
 743         {'L','I','N','K',0},
 744         {'D','A','T','A',0},
 745         {'M','S','I','_','T','R','A','N','S','F','O','R','M',0},
 746         {'M','S','I','_','T','R','A','N','S','F','O','R','M','_','R','E','F',0},
 747         {'M','S','I','_','P','A','C','K','A','G','E',0},
 748         {'F','L','A','G',0},
 749         {'M','S','I','_','C','U','S','T','O','M','_','A','C','T','I','O','N',0},
 750         {'F','L','A','G','_','R','E','F',0},
 751         {'A','C','T','I','O','N',0},
 752         {'L','O','O','K','U','P',0},
 753         {'C','O','N','T','E','X','T',0},
 754         {'C','O','N','T','E','X','T','_','R','E','F',0},
 755         {'I','n','v','a','l','i','d','T','a','g',0},
 756         {'I','n','v','a','l','i','d','T','a','g',0},
 757         {'I','n','v','a','l','i','d','T','a','g',0},
 758         {'I','n','v','a','l','i','d','T','a','g',0},
 759         {'I','n','v','a','l','i','d','T','a','g',0},
 760         {'I','n','v','a','l','i','d','T','a','g',0},
 761         {'S','P','C',0}
 762     },
 763     {   /* TAG_TYPE_STRING */
 764         {'I','n','v','a','l','i','d','T','a','g',0}
 765     },
 766     {   /* TAG_TYPE_BINARY */
 767         {'I','n','v','a','l','i','d','T','a','g',0},
 768         {'P','A','T','C','H','_','B','I','T','S',0},
 769         {'F','I','L','E','_','B','I','T','S',0},
 770         {'E','X','E','_','I','D',0},
 771         {'D','A','T','A','_','B','I','T','S',0},
 772         {'M','S','I','_','P','A','C','K','A','G','E','_','I','D',0},
 773         {'D','A','T','A','B','A','S','E','_','I','D',0},
 774         {'C','O','N','T','E','X','T','_','P','L','A','T','F','O','R','M','_','I','D',0},
 775         {'C','O','N','T','E','X','T','_','B','R','A','N','C','H','_','I','D',0},
 776         {'I','n','v','a','l','i','d','T','a','g',0},
 777         {'I','n','v','a','l','i','d','T','a','g',0},
 778         {'I','n','v','a','l','i','d','T','a','g',0},
 779         {'I','n','v','a','l','i','d','T','a','g',0},
 780         {'I','n','v','a','l','i','d','T','a','g',0},
 781         {'I','n','v','a','l','i','d','T','a','g',0},
 782         {'F','I','X','_','I','D',0},
 783         {'A','P','P','_','I','D',0}
 784     }
 785     };
 786
 787     /* sizes of tables in above array (# strings per type) */
 788     static const WORD limits[9] = {
 789         /* switch off TYPE_* nibble of last tag for each type */
 790         TAG_REINSTALL_UPGRADE & 0xFF,
 791         1,
 792         TAG_MATCH_MODE & 0xFF,
 793         TAG_URL_ID & 0xFF,
 794         TAG_FLAG_INSTALL & 0xFF,
 795         TAG_URL & 0xFF,
 796         TAG_SPC & 0xFF,
 797         1,
 798         TAG_APP_ID & 0xFF
 799     };
 800
 801     /* lookup tables for tags in range 0x800 + (0x1 -> 0xFF) | TYPE */
 802     static const WCHAR table2[9][3][17] = {
 803     { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_NULL */
 804     { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_BYTE */
 805     {
 806         {'T','A','G',0}, /* TAG_TYPE_WORD */
 807         {'I','N','D','E','X','_','T','A','G',0},
 808         {'I','N','D','E','X','_','K','E','Y',0}
 809     },
 810     { {'T','A','G','I','D',0} }, /* TAG_TYPE_DWORD */
 811     { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_QWORD */
 812     { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_STRINGREF */
 813     {
 814         {'S','T','R','I','N','G','T','A','B','L','E',0}, /* TAG_TYPE_LIST */
 815         {'I','N','D','E','X','E','S',0},
 816         {'I','N','D','E','X',0}
 817     },
 818     { {'S','T','R','I','N','G','T','A','B','L','E','_','I','T','E','M',0}, }, /* TAG_TYPE_STRING */
 819     { {'I','N','D','E','X','_','B','I','T','S',0} } /* TAG_TYPE_BINARY */
 820     };
 821
 822     /* sizes of tables in above array, hardcoded for simplicity */
 823     static const WORD limits2[9] = { 0, 0, 3, 1, 0, 0, 3, 1, 1 };
 824
 825     static const WCHAR null[] = {'N','U','L','L',0};
 826     static const WCHAR invalid[] = {'I','n','v','a','l','i','d','T','a','g',0};
 827
 828     BOOL switch_table; /* should we use table2 and limits2? */
 829     WORD index, type_index;
 830
 831     /* special case: null tag */
 832     if (tag == TAG_NULL)
 833         return null;
 834
 835     /* tags with only type mask or no type mask are invalid */
 836     if ((tag & ~TAG_TYPE_MASK) == 0 || (tag & TAG_TYPE_MASK) == 0)
 837         return invalid;
 838
 839     /* some valid tags are in range 0x800 + (0x1 -> 0xF) | TYPE */
 840     if ((tag & 0xF00) == 0x800)
 841         switch_table = TRUE;
 842     else if ((tag & 0xF00) == 0)
 843         switch_table = FALSE;
 844     else return invalid;
 845
 846     /* index of table in array is type nibble */
 847     type_index = (tag >> 12) - 1;
 848
 849     /* index of string in table is low byte */
 850     index = (tag & 0xFF) - 1;
 851
 852     /* bound check */
 853     if (type_index >= 9 || index >= (switch_table ? limits2[type_index] : limits[type_index]))
 854         return invalid;
 855
 856     /* tag is valid */
 857     return switch_table ? table2[type_index][index] : table[type_index][index];
 858 }