2 * Copyright 2011 André Hentschel
3 * Copyright 2013 Mislav Blažević
4 * Copyright 2015 Mark Jansen
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.
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.
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
21 #define WIN32_NO_STATUS
27 #include "wine/unicode.h"
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}};
34 static HANDLE
SdbpHeap(void);
36 #if SDBAPI_DEBUG_ALLOC
38 typedef struct SHIM_ALLOC_ENTRY
46 } SHIM_ALLOC_ENTRY
, *PSHIM_ALLOC_ENTRY
;
49 static RTL_AVL_TABLE g_SdbpAllocationTable
;
52 static RTL_GENERIC_COMPARE_RESULTS
53 NTAPI
ShimAllocCompareRoutine(_In_ PRTL_AVL_TABLE Table
, _In_ PVOID FirstStruct
, _In_ PVOID SecondStruct
)
55 PVOID First
= ((PSHIM_ALLOC_ENTRY
)FirstStruct
)->Address
;
56 PVOID Second
= ((PSHIM_ALLOC_ENTRY
)SecondStruct
)->Address
;
59 return GenericLessThan
;
60 else if (First
== Second
)
62 return GenericGreaterThan
;
65 static PVOID NTAPI
ShimAllocAllocateRoutine(_In_ PRTL_AVL_TABLE Table
, _In_ CLONG ByteSize
)
67 return HeapAlloc(SdbpHeap(), HEAP_ZERO_MEMORY
, ByteSize
);
70 static VOID NTAPI
ShimAllocFreeRoutine(_In_ PRTL_AVL_TABLE Table
, _In_ PVOID Buffer
)
72 HeapFree(SdbpHeap(), 0, Buffer
);
75 static void SdbpInsertAllocation(PVOID address
, SIZE_T size
, int line
, const char* file
)
77 SHIM_ALLOC_ENTRY Entry
= {0};
79 Entry
.Address
= address
;
83 RtlInsertElementGenericTableAvl(&g_SdbpAllocationTable
, &Entry
, sizeof(Entry
), NULL
);
86 static void SdbpUpdateAllocation(PVOID address
, PVOID newaddress
, SIZE_T size
, int line
, const char* file
)
88 SHIM_ALLOC_ENTRY Lookup
= {0};
89 PSHIM_ALLOC_ENTRY Entry
;
90 Lookup
.Address
= address
;
91 Entry
= RtlLookupElementGenericTableAvl(&g_SdbpAllocationTable
, &Lookup
);
93 if (address
== newaddress
)
99 Lookup
.Address
= newaddress
;
103 Lookup
.Prev
= address
;
104 RtlInsertElementGenericTableAvl(&g_SdbpAllocationTable
, &Lookup
, sizeof(Lookup
), NULL
);
105 Entry
->Next
= newaddress
;
109 static void SdbpRemoveAllocation(PVOID address
, int line
, const char* file
)
112 SHIM_ALLOC_ENTRY Lookup
= {0};
113 PSHIM_ALLOC_ENTRY Entry
;
115 sprintf(buf
, "\r\n===============\r\n%s(%d): SdbpFree called, tracing alloc:\r\n", file
, line
);
116 OutputDebugStringA(buf
);
118 Lookup
.Address
= address
;
119 while (Lookup
.Address
)
121 Entry
= RtlLookupElementGenericTableAvl(&g_SdbpAllocationTable
, &Lookup
);
125 RtlDeleteElementGenericTableAvl(&g_SdbpAllocationTable
, Entry
);
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
;
134 Lookup
.Address
= NULL
;
137 sprintf(buf
, "\r\n===============\r\n");
138 OutputDebugStringA(buf
);
143 static HANDLE g_Heap
;
144 void SdbpHeapInit(void)
146 #if SDBAPI_DEBUG_ALLOC
147 RtlInitializeGenericTableAvl(&g_SdbpAllocationTable
, ShimAllocCompareRoutine
,
148 ShimAllocAllocateRoutine
, ShimAllocFreeRoutine
, NULL
);
150 g_Heap
= HeapCreate(0, 0x10000, 0);
153 void SdbpHeapDeinit(void)
155 #if SDBAPI_DEBUG_ALLOC
156 if (g_SdbpAllocationTable
.NumberGenericTableElements
!= 0)
162 static HANDLE
SdbpHeap(void)
167 LPVOID
SdbpAlloc(SIZE_T size
168 #if SDBAPI_DEBUG_ALLOC
169 , int line
, const char* file
173 LPVOID mem
= HeapAlloc(SdbpHeap(), HEAP_ZERO_MEMORY
, size
);
174 #if SDBAPI_DEBUG_ALLOC
175 SdbpInsertAllocation(mem
, size
, line
, file
);
180 LPVOID
SdbpReAlloc(LPVOID mem
, SIZE_T size
181 #if SDBAPI_DEBUG_ALLOC
182 , int line
, const char* file
186 LPVOID newmem
= HeapReAlloc(SdbpHeap(), HEAP_ZERO_MEMORY
, mem
, size
);
187 #if SDBAPI_DEBUG_ALLOC
188 SdbpUpdateAllocation(mem
, newmem
, size
, line
, file
);
193 void SdbpFree(LPVOID mem
194 #if SDBAPI_DEBUG_ALLOC
195 , int line
, const char* file
199 #if SDBAPI_DEBUG_ALLOC
200 SdbpRemoveAllocation(mem
, line
, file
);
202 HeapFree(SdbpHeap(), 0, mem
);
205 DWORD
SdbpStrlen(PCWSTR string
)
207 return (lstrlenW(string
) + 1) * sizeof(WCHAR
);
210 PWSTR
SdbpStrDup(LPCWSTR string
)
212 PWSTR ret
= SdbpAlloc(SdbpStrlen(string
));
213 lstrcpyW(ret
, string
);
218 BOOL WINAPI
SdbpOpenMemMappedFile(LPCWSTR path
, PMEMMAPPED mapping
)
221 OBJECT_ATTRIBUTES ObjectAttributes
;
222 IO_STATUS_BLOCK IoStatusBlock
;
223 FILE_STANDARD_INFORMATION FileStandard
;
224 UNICODE_STRING FileName
;
226 RtlZeroMemory(mapping
, sizeof(*mapping
));
228 if(!RtlDosPathNameToNtPathName_U(path
, &FileName
, NULL
, NULL
))
230 RtlFreeUnicodeString(&FileName
);
234 InitializeObjectAttributes(&ObjectAttributes
, &FileName
, OBJ_CASE_INSENSITIVE
, NULL
, NULL
);
235 Status
= NtOpenFile(&mapping
->file
, GENERIC_READ
| SYNCHRONIZE
, &ObjectAttributes
, &IoStatusBlock
, FILE_SHARE_READ
, FILE_SYNCHRONOUS_IO_NONALERT
);
236 RtlFreeUnicodeString(&FileName
);
238 if (!NT_SUCCESS(Status
))
240 SHIM_ERR("Failed to open file %S: 0x%lx\n", path
, Status
);
244 Status
= NtCreateSection(&mapping
->section
, STANDARD_RIGHTS_REQUIRED
| SECTION_QUERY
| SECTION_MAP_READ
, 0, 0, PAGE_READONLY
, SEC_COMMIT
, mapping
->file
);
245 if (!NT_SUCCESS(Status
))
248 if (Status
== STATUS_MAPPED_FILE_SIZE_ZERO
)
250 NtClose(mapping
->file
);
251 mapping
->file
= mapping
->section
= NULL
;
254 SHIM_ERR("Failed to create mapping for file: 0x%lx\n", Status
);
258 Status
= NtQueryInformationFile(mapping
->file
, &IoStatusBlock
, &FileStandard
, sizeof(FileStandard
), FileStandardInformation
);
259 if (!NT_SUCCESS(Status
))
261 SHIM_ERR("Failed to read file info for file: 0x%lx\n", Status
);
265 mapping
->mapped_size
= mapping
->size
= FileStandard
.EndOfFile
.LowPart
;
266 Status
= NtMapViewOfSection(mapping
->section
, NtCurrentProcess(), (PVOID
*)&mapping
->view
, 0, 0, 0, &mapping
->mapped_size
, ViewUnmap
, 0, PAGE_READONLY
);
267 if (!NT_SUCCESS(Status
))
269 SHIM_ERR("Failed to map view of file: 0x%lx\n", Status
);
278 if (mapping
->section
)
279 NtClose(mapping
->section
);
280 NtClose(mapping
->file
);
285 void WINAPI
SdbpCloseMemMappedFile(PMEMMAPPED mapping
)
287 /* Prevent a VAD warning */
289 NtUnmapViewOfSection(NtCurrentProcess(), mapping
->view
);
290 NtClose(mapping
->section
);
291 NtClose(mapping
->file
);
292 RtlZeroMemory(mapping
, sizeof(*mapping
));
296 * Parses a string to retrieve a GUID.
298 * @param [in] GuidString The string to parse.
299 * @param [out] Guid The resulting GUID.
301 * @return TRUE if it succeeds, FALSE if it fails.
303 BOOL WINAPI
SdbGUIDFromString(PCWSTR GuidString
, GUID
*Guid
)
305 UNICODE_STRING GuidString_u
;
306 RtlInitUnicodeString(&GuidString_u
, GuidString
);
307 return NT_SUCCESS(RtlGUIDFromString(&GuidString_u
, Guid
));
311 * Converts a GUID to a string.
313 * @param [in] Guid The GUID to convert.
314 * @param [out] GuidString The resulting string representation of Guid.
315 * @param [in] Length The length of GuidString.
317 * @return TRUE if it succeeds, FALSE if it fails.
319 BOOL WINAPI
SdbGUIDToString(CONST GUID
*Guid
, PWSTR GuidString
, SIZE_T Length
)
321 UNICODE_STRING GuidString_u
;
322 if(NT_SUCCESS(RtlStringFromGUID(Guid
, &GuidString_u
)))
324 HRESULT hr
= StringCchCopyNW(GuidString
, Length
, GuidString_u
.Buffer
, GuidString_u
.Length
/ 2);
325 RtlFreeUnicodeString(&GuidString_u
);
326 return SUCCEEDED(hr
);
332 * Checks if the specified GUID is a NULL GUID
334 * @param [in] Guid The GUID to check.
336 * @return TRUE if it is a NULL GUID.
338 BOOL WINAPI
SdbIsNullGUID(CONST GUID
*Guid
)
340 static GUID NullGuid
= { 0 };
341 return !Guid
|| IsEqualGUID(&NullGuid
, Guid
);
345 * Get the GUID from one of the standard databases.
347 * @param [in] Flags The ID to retrieve the guid from. (See SDB_DATABASE_MAIN_[xxx])
348 * @param [out] Guid The resulting GUID.
350 * @return TRUE if a known database ID.
352 BOOL WINAPI
SdbGetStandardDatabaseGUID(DWORD Flags
, GUID
* Guid
)
354 const GUID
* copy_from
= NULL
;
355 switch(Flags
& HID_DATABASE_TYPE_MASK
)
357 case SDB_DATABASE_MAIN_MSI
:
358 copy_from
= &GUID_DATABASE_MSI
;
360 case SDB_DATABASE_MAIN_SHIM
:
361 copy_from
= &GUID_DATABASE_SHIM
;
363 case SDB_DATABASE_MAIN_DRIVERS
:
364 copy_from
= &GUID_DATABASE_DRIVERS
;
367 SHIM_ERR("Cannot obtain database guid for databases other than main\n");
372 memcpy(Guid
, copy_from
, sizeof(GUID
));
378 * Converts specified tag into a string.
380 * @param [in] tag The tag which will be converted to a string.
382 * @return Success: Pointer to the string matching specified tag, or L"InvalidTag" on failure.
384 LPCWSTR WINAPI
SdbTagToString(TAG tag
)
386 /* lookup tables for tags in range 0x1 -> 0xFF | TYPE */
387 static const WCHAR table
[9][0x32][25] = {
388 { /* TAG_TYPE_NULL */
389 {'I','N','C','L','U','D','E',0},
390 {'G','E','N','E','R','A','L',0},
391 {'M','A','T','C','H','_','L','O','G','I','C','_','N','O','T',0},
392 {'A','P','P','L','Y','_','A','L','L','_','S','H','I','M','S',0},
393 {'U','S','E','_','S','E','R','V','I','C','E','_','P','A','C','K','_','F','I','L','E','S',0},
394 {'M','I','T','I','G','A','T','I','O','N','_','O','S',0},
395 {'B','L','O','C','K','_','U','P','G','R','A','D','E',0},
396 {'I','N','C','L','U','D','E','E','X','C','L','U','D','E','D','L','L',0},
397 {'R','A','C','_','E','V','E','N','T','_','O','F','F',0},
398 {'T','E','L','E','M','E','T','R','Y','_','O','F','F',0},
399 {'S','H','I','M','_','E','N','G','I','N','E','_','O','F','F',0},
400 {'L','A','Y','E','R','_','P','R','O','P','A','G','A','T','I','O','N','_','O','F','F',0},
401 {'R','E','I','N','S','T','A','L','L','_','U','P','G','R','A','D','E',0}
403 { /* TAG_TYPE_BYTE */
404 {'I','n','v','a','l','i','d','T','a','g',0}
406 { /* TAG_TYPE_WORD */
407 {'M','A','T','C','H','_','M','O','D','E',0}
409 { /* TAG_TYPE_DWORD */
411 {'O','F','F','S','E','T',0},
412 {'C','H','E','C','K','S','U','M',0},
413 {'S','H','I','M','_','T','A','G','I','D',0},
414 {'P','A','T','C','H','_','T','A','G','I','D',0},
415 {'M','O','D','U','L','E','_','T','Y','P','E',0},
416 {'V','E','R','D','A','T','E','H','I',0},
417 {'V','E','R','D','A','T','E','L','O',0},
418 {'V','E','R','F','I','L','E','O','S',0},
419 {'V','E','R','F','I','L','E','T','Y','P','E',0},
420 {'P','E','_','C','H','E','C','K','S','U','M',0},
421 {'P','R','E','V','O','S','M','A','J','O','R','V','E','R',0},
422 {'P','R','E','V','O','S','M','I','N','O','R','V','E','R',0},
423 {'P','R','E','V','O','S','P','L','A','T','F','O','R','M','I','D',0},
424 {'P','R','E','V','O','S','B','U','I','L','D','N','O',0},
425 {'P','R','O','B','L','E','M','S','E','V','E','R','I','T','Y',0},
426 {'L','A','N','G','I','D',0},
427 {'V','E','R','_','L','A','N','G','U','A','G','E',0},
428 {'I','n','v','a','l','i','d','T','a','g',0},
429 {'E','N','G','I','N','E',0},
430 {'H','T','M','L','H','E','L','P','I','D',0},
431 {'I','N','D','E','X','_','F','L','A','G','S',0},
432 {'F','L','A','G','S',0},
433 {'D','A','T','A','_','V','A','L','U','E','T','Y','P','E',0},
434 {'D','A','T','A','_','D','W','O','R','D',0},
435 {'L','A','Y','E','R','_','T','A','G','I','D',0},
436 {'M','S','I','_','T','R','A','N','S','F','O','R','M','_','T','A','G','I','D',0},
437 {'L','I','N','K','E','R','_','V','E','R','S','I','O','N',0},
438 {'L','I','N','K','_','D','A','T','E',0},
439 {'U','P','T','O','_','L','I','N','K','_','D','A','T','E',0},
440 {'O','S','_','S','E','R','V','I','C','E','_','P','A','C','K',0},
441 {'F','L','A','G','_','T','A','G','I','D',0},
442 {'R','U','N','T','I','M','E','_','P','L','A','T','F','O','R','M',0},
443 {'O','S','_','S','K','U',0},
444 {'O','S','_','P','L','A','T','F','O','R','M',0},
445 {'A','P','P','_','N','A','M','E','_','R','C','_','I','D',0},
446 {'V','E','N','D','O','R','_','N','A','M','E','_','R','C','_','I','D',0},
447 {'S','U','M','M','A','R','Y','_','M','S','G','_','R','C','_','I','D',0},
448 {'V','I','S','T','A','_','S','K','U',0},
449 {'D','E','S','C','R','I','P','T','I','O','N','_','R','C','_','I','D',0},
450 {'P','A','R','A','M','E','T','E','R','1','_','R','C','_','I','D',0},
451 {'I','n','v','a','l','i','d','T','a','g',0},
452 {'I','n','v','a','l','i','d','T','a','g',0},
453 {'I','n','v','a','l','i','d','T','a','g',0},
454 {'I','n','v','a','l','i','d','T','a','g',0},
455 {'I','n','v','a','l','i','d','T','a','g',0},
456 {'I','n','v','a','l','i','d','T','a','g',0},
457 {'C','O','N','T','E','X','T','_','T','A','G','I','D',0},
458 {'E','X','E','_','W','R','A','P','P','E','R',0},
459 {'U','R','L','_','I','D',0}
461 { /* TAG_TYPE_QWORD */
463 {'B','I','N','_','F','I','L','E','_','V','E','R','S','I','O','N',0},
464 {'B','I','N','_','P','R','O','D','U','C','T','_','V','E','R','S','I','O','N',0},
465 {'M','O','D','T','I','M','E',0},
466 {'F','L','A','G','_','M','A','S','K','_','K','E','R','N','E','L',0},
467 {'U','P','T','O','_','B','I','N','_','P','R','O','D','U','C','T','_','V','E','R','S','I','O','N',0},
468 {'D','A','T','A','_','Q','W','O','R','D',0},
469 {'F','L','A','G','_','M','A','S','K','_','U','S','E','R',0},
470 {'F','L','A','G','S','_','N','T','V','D','M','1',0},
471 {'F','L','A','G','S','_','N','T','V','D','M','2',0},
472 {'F','L','A','G','S','_','N','T','V','D','M','3',0},
473 {'F','L','A','G','_','M','A','S','K','_','S','H','E','L','L',0},
474 {'U','P','T','O','_','B','I','N','_','F','I','L','E','_','V','E','R','S','I','O','N',0},
475 {'F','L','A','G','_','M','A','S','K','_','F','U','S','I','O','N',0},
476 {'F','L','A','G','_','P','R','O','C','E','S','S','P','A','R','A','M',0},
477 {'F','L','A','G','_','L','U','A',0},
478 {'F','L','A','G','_','I','N','S','T','A','L','L',0}
480 { /* TAG_TYPE_STRINGREF */
482 {'D','E','S','C','R','I','P','T','I','O','N',0},
483 {'M','O','D','U','L','E',0},
485 {'V','E','N','D','O','R',0},
486 {'A','P','P','_','N','A','M','E',0},
487 {'I','n','v','a','l','i','d','T','a','g',0},
488 {'C','O','M','M','A','N','D','_','L','I','N','E',0},
489 {'C','O','M','P','A','N','Y','_','N','A','M','E',0},
490 {'D','L','L','F','I','L','E',0},
491 {'W','I','L','D','C','A','R','D','_','N','A','M','E',0},
492 {'I','n','v','a','l','i','d','T','a','g',0},
493 {'I','n','v','a','l','i','d','T','a','g',0},
494 {'I','n','v','a','l','i','d','T','a','g',0},
495 {'I','n','v','a','l','i','d','T','a','g',0},
496 {'P','R','O','D','U','C','T','_','N','A','M','E',0},
497 {'P','R','O','D','U','C','T','_','V','E','R','S','I','O','N',0},
498 {'F','I','L','E','_','D','E','S','C','R','I','P','T','I','O','N',0},
499 {'F','I','L','E','_','V','E','R','S','I','O','N',0},
500 {'O','R','I','G','I','N','A','L','_','F','I','L','E','N','A','M','E',0},
501 {'I','N','T','E','R','N','A','L','_','N','A','M','E',0},
502 {'L','E','G','A','L','_','C','O','P','Y','R','I','G','H','T',0},
503 {'1','6','B','I','T','_','D','E','S','C','R','I','P','T','I','O','N',0},
504 {'A','P','P','H','E','L','P','_','D','E','T','A','I','L','S',0},
505 {'L','I','N','K','_','U','R','L',0},
506 {'L','I','N','K','_','T','E','X','T',0},
507 {'A','P','P','H','E','L','P','_','T','I','T','L','E',0},
508 {'A','P','P','H','E','L','P','_','C','O','N','T','A','C','T',0},
509 {'S','X','S','_','M','A','N','I','F','E','S','T',0},
510 {'D','A','T','A','_','S','T','R','I','N','G',0},
511 {'M','S','I','_','T','R','A','N','S','F','O','R','M','_','F','I','L','E',0},
512 {'1','6','B','I','T','_','M','O','D','U','L','E','_','N','A','M','E',0},
513 {'L','A','Y','E','R','_','D','I','S','P','L','A','Y','N','A','M','E',0},
514 {'C','O','M','P','I','L','E','R','_','V','E','R','S','I','O','N',0},
515 {'A','C','T','I','O','N','_','T','Y','P','E',0},
516 {'E','X','P','O','R','T','_','N','A','M','E',0},
519 { /* TAG_TYPE_LIST */
520 {'D','A','T','A','B','A','S','E',0},
521 {'L','I','B','R','A','R','Y',0},
522 {'I','N','E','X','C','L','U','D','E',0},
524 {'P','A','T','C','H',0},
527 {'M','A','T','C','H','I','N','G','_','F','I','L','E',0},
528 {'S','H','I','M','_','R','E','F',0},
529 {'P','A','T','C','H','_','R','E','F',0},
530 {'L','A','Y','E','R',0},
532 {'A','P','P','H','E','L','P',0},
535 {'M','S','I','_','T','R','A','N','S','F','O','R','M',0},
536 {'M','S','I','_','T','R','A','N','S','F','O','R','M','_','R','E','F',0},
537 {'M','S','I','_','P','A','C','K','A','G','E',0},
539 {'M','S','I','_','C','U','S','T','O','M','_','A','C','T','I','O','N',0},
540 {'F','L','A','G','_','R','E','F',0},
541 {'A','C','T','I','O','N',0},
542 {'L','O','O','K','U','P',0},
543 {'C','O','N','T','E','X','T',0},
544 {'C','O','N','T','E','X','T','_','R','E','F',0},
545 {'I','n','v','a','l','i','d','T','a','g',0},
546 {'I','n','v','a','l','i','d','T','a','g',0},
547 {'I','n','v','a','l','i','d','T','a','g',0},
548 {'I','n','v','a','l','i','d','T','a','g',0},
549 {'I','n','v','a','l','i','d','T','a','g',0},
550 {'I','n','v','a','l','i','d','T','a','g',0},
553 { /* TAG_TYPE_STRING */
554 {'I','n','v','a','l','i','d','T','a','g',0}
556 { /* TAG_TYPE_BINARY */
557 {'I','n','v','a','l','i','d','T','a','g',0},
558 {'P','A','T','C','H','_','B','I','T','S',0},
559 {'F','I','L','E','_','B','I','T','S',0},
560 {'E','X','E','_','I','D',0},
561 {'D','A','T','A','_','B','I','T','S',0},
562 {'M','S','I','_','P','A','C','K','A','G','E','_','I','D',0},
563 {'D','A','T','A','B','A','S','E','_','I','D',0},
564 {'C','O','N','T','E','X','T','_','P','L','A','T','F','O','R','M','_','I','D',0},
565 {'C','O','N','T','E','X','T','_','B','R','A','N','C','H','_','I','D',0},
566 {'I','n','v','a','l','i','d','T','a','g',0},
567 {'I','n','v','a','l','i','d','T','a','g',0},
568 {'I','n','v','a','l','i','d','T','a','g',0},
569 {'I','n','v','a','l','i','d','T','a','g',0},
570 {'I','n','v','a','l','i','d','T','a','g',0},
571 {'I','n','v','a','l','i','d','T','a','g',0},
572 {'F','I','X','_','I','D',0},
573 {'A','P','P','_','I','D',0}
577 /* sizes of tables in above array (# strings per type) */
578 static const WORD limits
[9] = {
579 /* switch off TYPE_* nibble of last tag for each type */
580 TAG_REINSTALL_UPGRADE
& 0xFF,
582 TAG_MATCH_MODE
& 0xFF,
584 TAG_FLAG_INSTALL
& 0xFF,
591 /* lookup tables for tags in range 0x800 + (0x1 -> 0xFF) | TYPE */
592 static const WCHAR table2
[9][3][17] = {
593 { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_NULL */
594 { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_BYTE */
596 {'T','A','G',0}, /* TAG_TYPE_WORD */
597 {'I','N','D','E','X','_','T','A','G',0},
598 {'I','N','D','E','X','_','K','E','Y',0}
600 { {'T','A','G','I','D',0} }, /* TAG_TYPE_DWORD */
601 { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_QWORD */
602 { {'I','n','v','a','l','i','d','T','a','g',0} }, /* TAG_TYPE_STRINGREF */
604 {'S','T','R','I','N','G','T','A','B','L','E',0}, /* TAG_TYPE_LIST */
605 {'I','N','D','E','X','E','S',0},
606 {'I','N','D','E','X',0}
608 { {'S','T','R','I','N','G','T','A','B','L','E','_','I','T','E','M',0}, }, /* TAG_TYPE_STRING */
609 { {'I','N','D','E','X','_','B','I','T','S',0} } /* TAG_TYPE_BINARY */
612 /* sizes of tables in above array, hardcoded for simplicity */
613 static const WORD limits2
[9] = { 0, 0, 3, 1, 0, 0, 3, 1, 1 };
615 static const WCHAR null
[] = {'N','U','L','L',0};
616 static const WCHAR invalid
[] = {'I','n','v','a','l','i','d','T','a','g',0};
618 BOOL switch_table
; /* should we use table2 and limits2? */
619 WORD index
, type_index
;
621 /* special case: null tag */
625 /* tags with only type mask or no type mask are invalid */
626 if ((tag
& ~TAG_TYPE_MASK
) == 0 || (tag
& TAG_TYPE_MASK
) == 0)
629 /* some valid tags are in range 0x800 + (0x1 -> 0xF) | TYPE */
630 if ((tag
& 0xF00) == 0x800)
632 else if ((tag
& 0xF00) == 0)
633 switch_table
= FALSE
;
636 /* index of table in array is type nibble */
637 type_index
= (tag
>> 12) - 1;
639 /* index of string in table is low byte */
640 index
= (tag
& 0xFF) - 1;
643 if (type_index
>= 9 || index
>= (switch_table
? limits2
[type_index
] : limits
[type_index
]))
647 return switch_table
? table2
[type_index
][index
] : table
[type_index
][index
];