able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/public/internal/windows/inc/shimdb.h

2464 lines
62 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*--
Copyright (c) Microsoft Corporation. All rights reserved.
Module Name:
shimdb.h
Abstract:
header for the database file access functions used by the App Compat shimming system
Author:
dmunsil 02/02/2000
Revision History:
Notes:
This "database" is more of a tagged file, designed to mimic the structure of an XML
file. An XML file can be converted into this packed data format easily, and all strings
will by default be packed into a stringtable and referenced by a DWORD identifier, so files
that contain a lot of common strings (like the XML used by the App Compat tema) will not
bloat.
To see the actual tags used by the shimdb, look in shimtags.h.
For the high-level interface used by the loader in NTDLL, look at ntbaseapi.c
--*/
#ifndef _SHIMDB_H_
#define _SHIMDB_H_
/*++
Supported configurations:
UNICODE with NT apis
ANSI with WIN32 apis
By default the library is UNICODE
To use (and link) Win32 library
--*/
#ifdef SDB_ANSI_LIB
#define LPCTSTR LPCSTR
#define LPTSTR LPSTR
#define TCHAR CHAR
#else
#define LPCTSTR LPCWSTR
#define LPTSTR LPWSTR
#define TCHAR WCHAR
#endif
#define SDBAPI STDAPICALLTYPE
typedef WORD TAG;
typedef WORD TAG_TYPE;
typedef DWORD TAGID;
typedef DWORD TAG_OFFSET;
typedef DWORD STRINGREF;
typedef DWORD INDEXID;
#define TAGID_NULL 0
#define STRINGREF_NULL 0
#define INDEXID_NULL ((INDEXID)-1)
#define TAG_NULL 0
#define TAGID_ROOT 0 // implied root list tag that can be passed in as a parent
#define TAG_SIZE_UNFINISHED 0xFFFFFFFF
//
// define TAGREF so we can use tags accross databases
//
typedef DWORD TAGREF;
///////////////////////////////////////////////////////////////////////////////
//
// TAG TYPES
//
//
// The most significant 4 bits tell you the basic type and size of data,
// and the lower 12 are the specific tag.
//
// In this way, even if we add more tags to the db, older readers can read
// the data because the type is either implied (for the first 5 types)
// or supplied (for all other types).
//
// WARNING: it is important that only the first 5 types have implied sizes.
// any future types should use a size or backwards compatibility will not be
// maintained.
//
// The following tags have an implied size.
//
#define TAG_TYPE_NULL 0x1000 // implied size 0
#define TAG_TYPE_BYTE 0x2000 // implied size 1
#define TAG_TYPE_WORD 0x3000 // implied size 2
#define TAG_TYPE_DWORD 0x4000 // implied size 4
#define TAG_TYPE_QWORD 0x5000 // implied size 8
#define TAG_TYPE_STRINGREF 0x6000 // implied size 4, for strings that should be tokenized
//
// These tags have a size after them (the size is type TAG_OFFSET)
//
#define TAG_TYPE_LIST 0x7000
#define TAG_TYPE_STRING 0x8000
#define TAG_TYPE_BINARY 0x9000
#define TAGREF_NULL 0
#define TAGREF_ROOT 0
//
// Special define for stripping out just the type from a tag.
//
#define TAG_STRIP_TYPE 0xF000
//
// This macro strips off the lower bits of the TAG and returns the upper bits, which
// give the basic type of tag. All the tag types are defined above.
//
// The type info is purely used internally by the DB to tell whether the tag has
// an implied size, or if the DB needs to do something special with the data before
// handing it back to the caller.
//
#define GETTAGTYPE(tag) ((tag) & TAG_STRIP_TYPE)
typedef PVOID HSDB;
struct tagHOOKAPI;
typedef struct tagHOOKAPIEX {
DWORD dwShimID;
struct tagHOOKAPI* pTopOfChain;
struct tagHOOKAPI* pNext;
} HOOKAPIEX, *PHOOKAPIEX;
typedef struct tagHOOKAPI {
char* pszModule; // the name of the module
char* pszFunctionName; // the name of the API in the module
PVOID pfnNew; // pointer to the new stub API
PVOID pfnOld; // pointer to the old API
DWORD dwFlags; // used internally - important info about status
union {
struct tagHOOKAPI* pNextHook; // used internally - (obsolete -- old mechanism)
PHOOKAPIEX pHookEx; // used internally - pointer to an internal extended
// info struct
};
} HOOKAPI, *PHOOKAPI;
//
// OBSOLETE !
//
// If the hook DLL ever patches LoadLibraryA/W it must call PatchNewModules
// so that the shim knows to patch any new loaded DLLs
//
typedef VOID (*PFNPATCHNEWMODULES)(VOID);
typedef PHOOKAPI (*PFNGETHOOKAPIS)(LPSTR pszCmdLine,
LPWSTR pwszShim,
DWORD* pdwHooksCount);
//
// These structures are part of the protocol between NTVDM and the shim engine
// for patching task "import tables"
//
typedef struct tagAPIDESC {
char* pszModule;
char* pszApi;
} APIDESC, *PAPIDESC;
typedef struct tagVDMTABLE {
int nApiCount;
PVOID* ppfnOrig;
APIDESC* pApiDesc;
} VDMTABLE, *PVDMTABLE;
//
// Shim engine notification events
//
#define SN_STATIC_DLLS_INITIALIZED 1
#define SN_PROCESS_DYING 2
#define SN_DLL_LOADING 3
//
// This is the prototype for the notification function
// that the shim engine calls into the shim DLLs for various
// reasons (defined above).
//
typedef void (*PFNNOTIFYSHIMS)(int nReason, UINT_PTR extraInfo);
#define SHIM_COMMAND_LINE_MAX_BUFFER 1024
///////////////////////////////////////////////////////////////////////////////
//
// PATCH STRUCTURES
//
typedef struct _PATCHOP {
DWORD dwOpcode; // Opcode to be performed
DWORD dwNextOpcode; // Relative offset to next opcode
#pragma warning( disable : 4200 )
BYTE data[]; // Data for this operation type is dependent
// on the op-code.
#pragma warning( default : 4200 )
} PATCHOP, *PPATCHOP;
typedef struct _RELATIVE_MODULE_ADDRESS {
DWORD address; // Relative address from beginning of loaded module
BYTE reserved[3]; // Reserved for system use
WCHAR moduleName[32]; // Module name for this address.
} RELATIVE_MODULE_ADDRESS, *PRELATIVE_MODULE_ADDRESS;
typedef struct _PATCHWRITEDATA {
DWORD dwSizeData; // Size of patch data in bytes
RELATIVE_MODULE_ADDRESS rva; // Relative address where this patch data is
// to be applied.
#pragma warning( disable : 4200 )
BYTE data[]; // Patch data bytes.
#pragma warning( default : 4200 )
} PATCHWRITEDATA, *PPATCHWRITEDATA;
typedef struct _PATCHMATCHDATA {
DWORD dwSizeData; // Size of matching data data in bytes
RELATIVE_MODULE_ADDRESS rva; // Relative address where this patch data is
// to be verified.
#pragma warning( disable : 4200 )
BYTE data[]; // Matching data bytes.
#pragma warning( default : 4200 )
} PATCHMATCHDATA, *PPATCHMATCHDATA;
typedef enum _PATCHOPCODES {
PEND = 0, // no more opcodes
PSAA, // Set Activate Address, SETACTIVATEADDRESS
PWD, // Patch Write Data, PATCHWRITEDATA
PNOP, // No Operation
PMAT, // Patch match the matching bytes but do not replace the bytes.
} PATCHOPCODES;
//
// HEADER STRUCTURE
//
#define SHIMDB_MAGIC 0x66626473 // 'sdbf' (reversed because of little-endian ordering)
#define SHIMDB_MAJOR_VERSION 2 // Don't change this unless fundamentals
// change (like TAG size, etc.)
#define SHIMDB_MINOR_VERSION 0 // This is for info only -- ignored on read
typedef struct _DB_HEADER {
DWORD dwMajorVersion;
DWORD dwMinorVersion;
DWORD dwMagic;
} DB_HEADER, *PDB_HEADER;
//
// INDEX_RECORD STRUCTURE
//
#pragma pack (push, 4)
typedef struct _INDEX_RECORD {
ULONGLONG ullKey;
TAGID tiRef;
} INDEX_RECORD;
typedef INDEX_RECORD UNALIGNED *PINDEX_RECORD;
#pragma pack (pop)
//
// Forward declaration.
//
struct _DB;
typedef struct _DB* PDB;
//
// This flag is used in apphelp entries.
// When set, it denotes entries that only have apphelp information.
//
#define SHIMDB_APPHELP_ONLY 0x00000001
typedef enum _PATH_TYPE {
DOS_PATH,
NT_PATH
} PATH_TYPE;
typedef struct _FIND_INFO {
TAGID tiIndex;
TAGID tiCurrent;
TAGID tiEndIndex; // last record after FindFirst if index is UNIQUE
TAG tName;
DWORD dwIndexRec;
DWORD dwFlags;
ULONGLONG ullKey; // calculated key for this entry
union {
LPCTSTR szName;
DWORD dwName; // for dword search
GUID* pguidName;
};
} FIND_INFO, *PFIND_INFO;
#define SDB_MAX_LAYERS 8
#define SDB_MAX_EXES 4
#define SDB_MAX_SDBS 16
typedef struct tagSDBQUERYRESULT {
TAGREF atrExes[SDB_MAX_EXES];
TAGREF atrLayers[SDB_MAX_LAYERS];
TAGREF trAppHelp; // If there is an apphelp to display, the EXE
// entry will be here.
DWORD dwExeCount; // number of elements in atrexes
DWORD dwLayerCount; // number of elements in atrLayers
GUID guidID; // last exe's GUID
DWORD dwFlags; // last exe's flags
//
// New entries are here to preserve compatibility.
// Only some entries will be valid in this map.
//
DWORD dwCustomSDBMap; // entry map, technically not needed
GUID rgGuidDB[SDB_MAX_SDBS];
} SDBQUERYRESULT, *PSDBQUERYRESULT;
//
// Information related to TAG_DRIVER tag in the db.
// Use SdbReadDriverInformation to retrieve this struct.
//
typedef struct tagENTRYINFO {
GUID guidID; // guid ID for this entry
DWORD dwFlags; // registry flags for this exe
TAGID tiData; // optional id for a TAG_DATA tag
GUID guidDB; // optional guid for the database where
// this entry is located
} SDBENTRYINFO, *PSDBENTRYINFO;
//
// Flags used by SDBDATABASEINFO.dwFlags
//
#define DBINFO_GUID_VALID 0x00000001
#define DBINFO_SDBALLOC 0x10000000
typedef struct tagSDBDATABASEINFO {
DWORD dwFlags; // flags -- which struct members are valid (and
// perhaps flags relevant to db content in the future
DWORD dwVersionMajor; // major version
DWORD dwVersionMinor; // minor version (time stamp)
LPTSTR pszDescription; // description, optional
GUID guidDB; // database id
} SDBDATABASEINFO, *PSDBDATABASEINFO;
///////////////////////////////////////////////////////////////////////////////
//
// APIs to read/write/access the shim database
//
//
// READ functions
//
BYTE
SDBAPI
SdbReadBYTETag(
IN PDB pdb,
IN TAGID tiWhich,
IN BYTE jDefault
);
WORD
SDBAPI
SdbReadWORDTag(
IN PDB pdb,
IN TAGID tiWhich,
IN WORD wDefault
);
DWORD
SDBAPI
SdbReadDWORDTag(
IN PDB pdb,
IN TAGID tiWhich,
IN DWORD dwDefault
);
ULONGLONG
SDBAPI
SdbReadQWORDTag(
IN PDB pdb,
IN TAGID tiWhich,
IN ULONGLONG qwDefault
);
BOOL
SDBAPI
SdbReadBinaryTag(
IN PDB pdb,
IN TAGID tiWhich,
OUT PBYTE pBuffer,
IN DWORD dwBufferSize
);
BOOL
SDBAPI
SdbReadStringTag(
IN PDB pdb,
IN TAGID tiWhich,
OUT LPTSTR pwszBuffer,
IN DWORD dwBufferSize
);
LPTSTR
SDBAPI
SdbGetStringTagPtr(
IN PDB pdb,
IN TAGID tiWhich
);
BYTE
SDBAPI
SdbReadBYTETagRef(
IN HSDB hSDB,
IN TAGREF trWhich,
IN BYTE jDefault
);
WORD
SDBAPI
SdbReadWORDTagRef(
IN HSDB hSDB,
IN TAGREF trWhich,
IN WORD wDefault
);
DWORD
SDBAPI
SdbReadDWORDTagRef(
IN HSDB hSDB,
IN TAGREF trWhich,
IN DWORD dwDefault
);
ULONGLONG
SDBAPI
SdbReadQWORDTagRef(
IN HSDB hSDB,
IN TAGREF trWhich,
IN ULONGLONG qwDefault
);
BOOL
SDBAPI
SdbReadStringTagRef(
IN HSDB hSDB,
IN TAGREF trWhich,
OUT LPTSTR pwszBuffer,
IN DWORD dwBufferSize
);
//
// GENERAL ACCESS FUNCTIONS
//
TAGID
SDBAPI
SdbGetFirstChild(
IN PDB pdb,
IN TAGID tiParent
);
TAGID
SDBAPI
SdbGetNextChild(
IN PDB pdb,
IN TAGID tiParent,
IN TAGID tiPrev
);
TAG
SDBAPI
SdbGetTagFromTagID(
IN PDB pdb,
IN TAGID tiWhich
);
DWORD
SDBAPI
SdbGetTagDataSize(
IN PDB pdb,
IN TAGID tiWhich
);
PVOID
SDBAPI
SdbGetBinaryTagData(
IN PDB pdb,
IN TAGID tiWhich
);
BOOL
SDBAPI
SdbIsTagrefFromMainDB(
TAGREF trWhich
);
BOOL
SDBAPI
SdbIsTagrefFromLocalDB(
TAGREF trWhich
);
typedef struct tagATTRINFO *PATTRINFO;
//////////////////////////////////////////////////////////////////////////
// Grab Matching Information Function Declaration
//
//
// Filters available for SdbGrabMatchingInfo
//
#define GRABMI_FILTER_NORMAL 0
#define GRABMI_FILTER_PRIVACY 1
#define GRABMI_FILTER_DRIVERS 2
#define GRABMI_FILTER_VERBOSE 3
#define GRABMI_FILTER_SYSTEM 4
#define GRABMI_FILTER_THISFILEONLY 5
#define GRABMI_FILTER_NOCLOSE 0x10000000
#define GRABMI_FILTER_APPEND 0x20000000
#define GRABMI_FILTER_LIMITFILES 0x40000000
#define GRABMI_FILTER_NORECURSE 0x80000000
#define GRABMI_IMPOSED_FILE_LIMIT 25
typedef enum GMI_RESULT {
GMI_FAILED = FALSE,
GMI_SUCCESS = TRUE,
GMI_CANCELLED = -1
} GMI_RESULT;
BOOL
SDBAPI
SdbGrabMatchingInfo(
LPCTSTR szMatchingPath,
DWORD dwFilter,
LPCTSTR szFile
);
typedef BOOL (CALLBACK* PFNGMIProgressCallback)(
LPVOID lpvCallbackParam, // application-defined parameter
LPCTSTR lpszRoot, // root directory path
LPCTSTR lpszRelative, // relative path
PATTRINFO pAttrInfo, // attributes
LPCWSTR pwszXML // resulting xml
);
GMI_RESULT
SDBAPI
SdbGrabMatchingInfoEx(
LPCTSTR szMatchingPath,
DWORD dwFilter,
LPCTSTR szFile,
PFNGMIProgressCallback pfnCallback,
LPVOID lpvCallbackParam
);
//
// Module-type constants
//
#define MT_UNKNOWN_MODULE 0
#define MT_DOS_MODULE 1
#define MT_W16_MODULE 2
#define MT_W32_MODULE 3
//////////////////////////////////////////////////////////////////////////
//
// TAGREF functions
//
//////////////////////////////////////////////////////////////////////////
BOOL
SDBAPI
SdbTagIDToTagRef(
IN HSDB hSDB,
IN PDB pdb,
IN TAGID tiWhich,
OUT TAGREF* ptrWhich
);
BOOL
SDBAPI
SdbTagRefToTagID(
IN HSDB hSDB,
IN TAGREF trWhich,
OUT PDB* ppdb,
OUT TAGID* ptiWhich
);
//
// SEARCH functions
//
TAGID
SDBAPI
SdbFindFirstTag(
IN PDB pdb,
IN TAGID tiParent,
IN TAG tTag
);
TAGID
SDBAPI
SdbFindNextTag(
IN PDB pdb,
IN TAGID tiParent,
IN TAGID tiPrev
);
TAGID
SDBAPI
SdbFindFirstNamedTag(
IN PDB pdb,
IN TAGID tiParent,
IN TAG tToFind,
IN TAG tName,
IN LPCTSTR pszName
);
TAGREF
SDBAPI
SdbFindFirstTagRef(
IN HSDB hSDB,
IN TAGREF trParent,
IN TAG tTag
);
TAGREF
SDBAPI
SdbFindNextTagRef(
IN HSDB hSDB,
IN TAGREF trParent,
IN TAGREF trPrev
);
//
// DB access APIs
//
//
// Flags for SdbInitDatabase.
//
#define HID_DOS_PATHS 0x00000001 // use DOS paths
#define HID_DATABASE_FULLPATH 0x00000002 // pszDatabasePath is a full path to the main db
#define HID_NO_DATABASE 0x00000004 // do not open database at this time
#define HID_DATABASE_TYPE_MASK 0xF00F0000 // mask that shows whether we have any
// database type-related bits
//
// The flags could be OR'd with SDB_DATABASE_* bits
//
HSDB
SDBAPI
SdbInitDatabase(
IN DWORD dwFlags,
IN LPCTSTR pszDatabasePath
);
HSDB
SDBAPI
SdbInitDatabaseInMemory(
IN LPVOID pDatabaseImage,
IN DWORD dwImageSize
);
VOID
SDBAPI
SdbReleaseDatabase(
IN HSDB hSDB
);
//
// Information - retrieval functions
//
BOOL
SDBAPI
SdbGetDatabaseVersion(
IN LPCTSTR pwszFileName,
OUT LPDWORD lpdwMajor,
OUT LPDWORD lpdwMinor
);
BOOL
SDBAPI
SdbGetDatabaseInformation(
IN PDB pdb,
OUT PSDBDATABASEINFO pSdbInfo
);
BOOL
SDBAPI
SdbGetDatabaseID(
IN PDB pdb,
OUT GUID* pguidDB
);
DWORD
SDBAPI
SdbGetDatabaseDescription(
IN PDB pdb,
OUT LPTSTR pszDatabaseDescription,
IN DWORD BufferSize
);
VOID
SDBAPI
SdbFreeDatabaseInformation(
IN PSDBDATABASEINFO pDBInfo
);
BOOL
SDBAPI
SdbGetDatabaseInformationByName(
IN LPCTSTR pszDatabase,
OUT PSDBDATABASEINFO* ppdbInfo
);
#define SDBTYPE_SYSMAIN 0x00000001
#define SDBTYPE_SYSTEST 0x00000002
#define SDBTYPE_MSI 0x00000003
#define SDBTYPE_SHIM 0x00000004 // primarily shim db
#define SDBTYPE_APPHELP 0x00000005 // primarily type apphelp
#define SDBTYPE_CUSTOM 0x00010000 // this is an "OR" bit
//
// The function below exists only in user mode on win32 platform
//
BOOL
SDBAPI
SdbUnregisterDatabase(
IN GUID* pguidDB
);
BOOL
SDBAPI
SdbGetDatabaseRegPath(
IN GUID* pguidDB,
OUT LPTSTR pszDatabasePath,
IN DWORD dwBufferSize // size (in tchars) of the buffer
);
/////////////////////////////////////////////////////////////////
//
// Database types
// for SdbResolveDatabase and SdbRegisterDatabase
//
//
// flag that indicates that the database is the default one
// WILL NOT be set for custom databases
//
#define SDB_DATABASE_MAIN 0x80000000
#define SDB_DATABASE_TEST 0x40000000 // systest.sdb will have 0xc00000000
//
// types - one or more apply depending on the contents of the database
// (see HID_DATABASE_TYPE values, they should match database types 1:1)
#define SDB_DATABASE_SHIM 0x00010000 // set when database contains apps to be fixed by shimming
#define SDB_DATABASE_MSI 0x00020000 // set when database contains msi entries
#define SDB_DATABASE_DRIVERS 0x00040000 // set when database contains drivers to be blocked
#define SDB_DATABASE_DETAILS 0x00080000 // set when the db contains apphelp details
#define SDB_DATABASE_SP_DETAILS 0x00100000 // set when the db contains SP apphelp details
#define SDB_DATABASE_TYPE_MASK 0xF01F0000
//
// These constants should be used when derefencing "main" databases
//
#define SDB_DATABASE_MAIN_SHIM (SDB_DATABASE_SHIM | SDB_DATABASE_MSI | SDB_DATABASE_MAIN)
#define SDB_DATABASE_MAIN_MSI (SDB_DATABASE_MSI | SDB_DATABASE_MAIN)
#define SDB_DATABASE_MAIN_DRIVERS (SDB_DATABASE_DRIVERS | SDB_DATABASE_MAIN)
#define SDB_DATABASE_MAIN_TEST (SDB_DATABASE_TEST | SDB_DATABASE_MAIN | SDB_DATABASE_SHIM | SDB_DATABASE_MSI)
#define SDB_DATABASE_MAIN_DETAILS (SDB_DATABASE_DETAILS | SDB_DATABASE_MAIN)
#define SDB_DATABASE_MAIN_SP_DETAILS (SDB_DATABASE_SP_DETAILS | SDB_DATABASE_MAIN)
//
// These are internal GUIDs that always reference certain global databases
//
#define GUID_SZ_SYSMAIN_SDB _T("{11111111-1111-1111-1111-111111111111}");
#define GUID_SZ_APPHELP_SDB _T("{22222222-2222-2222-2222-222222222222}");
#define GUID_SZ_SYSTEST_SDB _T("{33333333-3333-3333-3333-333333333333}");
#define GUID_SZ_DRVMAIN_SDB _T("{F9AB2228-3312-4A73-B6F9-936D70E112EF}"};
//
// the following GUIDs are actually declared in sdbapi.c
//
EXTERN_C const GUID FAR GUID_SYSMAIN_SDB;
EXTERN_C const GUID FAR GUID_APPHELP_SDB;
EXTERN_C const GUID FAR GUID_APPHELP_SP_SDB;
EXTERN_C const GUID FAR GUID_SYSTEST_SDB;
EXTERN_C const GUID FAR GUID_DRVMAIN_SDB;
EXTERN_C const GUID FAR GUID_MSIMAIN_SDB;
BOOL
SDBAPI
SdbGetStandardDatabaseGUID(
IN DWORD dwDatabaseType,
OUT GUID* pGuidDB
);
BOOL
SDBAPI
SdbRegisterDatabase(
IN LPCTSTR pszDatabasePath,
IN DWORD dwDatabaseType
);
BOOL
SDBAPI
SdbRegisterDatabaseEx(
IN LPCTSTR pszDatabasePath,
IN DWORD dwDatabaseType,
IN PULONGLONG pTimeStamp
);
DWORD
SDBAPI
SdbResolveDatabase(
IN GUID* pguidDB, // pointer to the database guid to resolve
OUT LPDWORD lpdwDatabaseType, // optional pointer to the database type
OUT LPTSTR pszDatabasePath, // optional pointer to the database path
IN DWORD dwBufferSize // size of the buffer pszDatabasePath in tchars
);
PDB
SdbGetPDBFromGUID(
IN HSDB hSDB, // HSDB
IN GUID* pguidDB // the guid of the DB
);
BOOL
SdbGetDatabaseGUID(
IN HSDB hSDB, // HSDB of the sdbContext (optional)
IN PDB pdb, // PDB of the database in question
OUT GUID* pguidDB // the guid of the DB
);
TAGREF
SDBAPI
SdbFindMsiPackageByID(
IN HSDB hSDB,
IN GUID* pguidID
);
void
SdbpGetAppPatchDir(
LPTSTR szAppPatchPath
);
//
// GUID manipulation apis - not platform dependent
//
BOOL
SDBAPI
SdbGUIDFromString(
IN LPCTSTR lpszGuid,
OUT GUID* pGuid
);
BOOL
SDBAPI
SdbGUIDToString(
IN GUID* pGuid,
OUT LPTSTR pszGuid
);
BOOL
SDBAPI
SdbIsNullGUID(
IN GUID* pGuid
);
//
// open/create and close database.
//
PDB
SDBAPI
SdbOpenDatabase(
IN LPCTSTR pwszPath,
IN PATH_TYPE eType
);
BOOL
SDBAPI
SdbOpenLocalDatabase(
IN HSDB hSDB,
IN LPCTSTR pwszLocalDatabase
);
BOOL
SDBAPI
SdbCloseLocalDatabase(
IN HSDB hSDB
);
PDB
SDBAPI
SdbCreateDatabase(
IN LPCWSTR pwszPath,
IN PATH_TYPE eType
);
void
SDBAPI
SdbCloseDatabase(
IN PDB pdb
);
//
// Search the database looking for an entry for the specified exe.
//
//
// Flags for SdbGetMatchingExe dwFlags
//
#define SDBGMEF_IGNORE_ENVIRONMENT 0x00000001
BOOL
SdbGetMatchingExe(
IN HSDB hSDB OPTIONAL,
IN LPCTSTR pwszPath,
IN LPCTSTR szModuleName,
IN LPCTSTR pwszEnvironment,
IN DWORD dwFlags,
OUT PSDBQUERYRESULT pQueryResult
);
void
SdbReleaseMatchingExe(
IN HSDB hSDB,
IN TAGREF trExe
);
TAGREF
SDBAPI
SdbGetDatabaseMatch(
IN HSDB hSDB,
IN LPCTSTR szPath,
IN HANDLE FileHandle OPTIONAL,
IN LPVOID pImageBase OPTIONAL,
IN DWORD dwImageSize OPTIONAL
);
TAGREF
SdbGetLayerTagReg(
IN HSDB hSDB,
IN LPCTSTR szLayer
);
PDB
SDBAPI
SdbGetLocalPDB(
IN HSDB hSDB
);
LPTSTR
SDBAPI
SdbGetLayerName(
IN HSDB hSDB,
IN TAGREF trLayer
);
TAGREF
SDBAPI
SdbGetNamedLayer(
IN HSDB hSDB, // database context
IN TAGREF trLayerRef // tagref of a record referencing a layer
);
#define SBCE_ADDITIVE 0x00000001
#define SBCE_INCLUDESYSTEMEXES 0x00000002
#define SBCE_INHERITENV 0x00000004
DWORD
SdbBuildCompatEnvVariables(
IN HSDB hSDB,
IN SDBQUERYRESULT* psdbQuery,
IN DWORD dwFlags,
IN LPCWSTR pwszParentEnv OPTIONAL, // Environment which contains vars we
// shall inherit from
OUT LPWSTR pBuffer,
IN DWORD cbSize, // size of the buffer in tchars
OUT LPDWORD lpdwShimsCount OPTIONAL
);
//
// MSI-specific functionality
//
typedef enum tagSDBMSILOOKUPSTATE {
LOOKUP_NONE = 0, // this should be the first state
LOOKUP_LOCAL,
LOOKUP_CUSTOM,
LOOKUP_TEST,
LOOKUP_MAIN,
LOOKUP_DONE // this should be the last state
} SDBMSILOOKUPSTATE;
typedef struct tagSDBMSIFINDINFO {
TAGREF trMatch; // tagref of the matching package
GUID guidID; // guid of this current package
FIND_INFO sdbFindInfo; // standard sdb find info
// this is used to persist the state of the current search
//
SDBMSILOOKUPSTATE sdbLookupState;
DWORD dwCustomIndex;
} SDBMSIFINDINFO, *PSDBMSIFINDINFO;
typedef struct tagSDBMSITRANSFORMINFO {
LPCTSTR lpszTransformName; // name of the transform
TAGREF trTransform; // tagref of this transform
TAGREF trFile; // tagref of file for this transform (bits)
} SDBMSITRANSFORMINFO, *PSDBMSITRANSFORMINFO;
//
// Information for any individual MSI package
//
typedef struct tagMSIPACKAGEINFO {
GUID guidID; // unique guid for this entry
GUID guidMsiPackageID; // guid (non-unique, for this entry)
GUID guidDatabaseID; // guid of the database where this had been found
DWORD dwPackageFlags; // Package flags (see below)
} MSIPACKAGEINFO, *PMSIPACKAGEINFO;
#define MSI_PACKAGE_HAS_APPHELP 0x00000001
#define MSI_PACKAGE_HAS_SHIMS 0x00000002
TAGREF
SDBAPI
SdbFindFirstMsiPackage_Str(
IN HSDB hSDB,
IN LPCTSTR lpszGuid,
IN LPCTSTR lpszLocalDB,
OUT PSDBMSIFINDINFO pFindInfo
);
TAGREF
SDBAPI
SdbFindFirstMsiPackage(
IN HSDB hSDB, // in HSDB context
IN GUID* pGuidID, // in GUID that we're looking for
IN LPCTSTR lpszLocalDB, // in optional path to local db, dos path style
OUT PSDBMSIFINDINFO pFindInfo // pointer to our search context
);
TAGREF
SDBAPI
SdbFindNextMsiPackage(
IN HSDB hSDB,
IN OUT PSDBMSIFINDINFO pFindInfo
);
BOOL
SDBAPI
SdbGetMsiPackageInformation(
IN HSDB hSDB,
IN TAGREF trMatch,
OUT PMSIPACKAGEINFO pPackageInfo
);
DWORD
SDBAPI
SdbEnumMsiTransforms(
IN HSDB hSDB, // in HSDB context
IN TAGREF trMatch, // matched entry
OUT TAGREF* ptrBuffer, // array of tagrefs to fill with msi transform "fixes"
IN OUT DWORD* pdwBufferSize // pointer to the buffer size, receives the number of
// bytes written
);
BOOL
SDBAPI
SdbReadMsiTransformInfo(
IN HSDB hSDB, // HSDB context
IN TAGREF trTransformRef, // reference to a transform, returned
// by SdbEnumMsiTransforms
OUT PSDBMSITRANSFORMINFO pTransformInfo // information structure
);
BOOL
SDBAPI
SdbCreateMsiTransformFile(
IN HSDB hSDB, // context
IN LPCTSTR lpszFileName, // filename to write data to
IN PSDBMSITRANSFORMINFO pTransformInfo // pointer to the transform structure
);
TAGREF
SDBAPI
SdbFindCustomActionForPackage(
IN HSDB hSDB,
IN TAGREF trPackage,
IN LPCTSTR lpszCustomAction);
#define SdbGetFirstMsiTransformForPackage(hSDB, trPackage) \
(SdbFindFirstTagRef((hSDB), (trPackage), TAG_MSI_TRANSFORM_REF))
#define SdbGetNextMsiTransformForPackage(hSDB, trPackage, trPrevMatch) \
(SdbFindNextTagRef((hSDB), (trPackage), (trPrevMatch)))
//
// "disable" registry entry masks
//
#define SHIMREG_DISABLE_SHIM 0x00000001
#define SHIMREG_DISABLE_APPHELP 0x00000002 // disables apphelp
#define SHIMREG_APPHELP_NOUI 0x00000004 // suppress apphelp ui
#define SHIMREG_APPHELP_CANCEL 0x10000000 // returns CANCEL as a default action
#define SHIMREG_DISABLE_SXS 0x00000010
#define SHIMREG_DISABLE_LAYER 0x00000020
#define SHIMREG_DISABLE_DRIVER 0x00000040
BOOL
SDBAPI
SdbSetEntryFlags(
IN GUID* pGuidID,
IN DWORD dwFlags
);
BOOL
SDBAPI
SdbGetEntryFlags(
IN GUID* pGuid,
OUT LPDWORD lpdwFlags
);
//
// Flags used by Get/SetPermLayerKeys
//
#define GPLK_USER 0x00000001
#define GPLK_MACHINE 0x00000002
#define GPLK_ALL (GPLK_USER | GPLK_MACHINE)
BOOL
SDBAPI
SdbGetPermLayerKeys(
LPCTSTR szPath,
LPTSTR szLayers,
LPDWORD pdwBytes,
DWORD dwFlags
);
BOOL
SDBAPI
SdbSetPermLayerKeys(
LPCTSTR szPath,
LPCTSTR szLayers,
BOOL bMachine
);
BOOL
SDBAPI
SdbDeletePermLayerKeys(
LPCTSTR szPath,
BOOL bMachine
);
BOOL
SdbGetNthUserSdb(
IN HSDB hSDB, // context
IN LPCTSTR wszItemName, // item name (foo.exe or layer name)
IN BOOL bLayer, // true if layer name
IN OUT LPDWORD pdwIndex, // (0-based)
OUT GUID* pGuidDB // database guid
);
//
// APIs to pack/unpack appcompat data package.
//
BOOL
SdbPackAppCompatData(
IN HSDB hSDB,
IN PSDBQUERYRESULT pSdbQuery,
OUT PVOID* ppData,
OUT LPDWORD pdwSize
);
BOOL
SdbUnpackAppCompatData(
IN HSDB hSDB,
IN LPCWSTR pwszExeName,
IN PVOID pAppCompatData,
OUT PSDBQUERYRESULT pSdbQuery
);
DWORD
SdbGetAppCompatDataSize(
IN PVOID pAppCompatData
);
//
// DLL functions
//
BOOL
SdbGetDllPath(
IN HSDB hSDB,
IN TAGREF trDllRef,
OUT LPTSTR pwszBuffer
);
//
// PATCH functions
//
BOOL
SdbReadPatchBits(
IN HSDB hSDB,
IN TAGREF trPatchRef,
OUT PVOID pBuffer,
OUT LPDWORD lpdwBufferSize
);
//
// SDBDRIVERINFO query function
//
BOOL
SDBAPI
SdbReadEntryInformation(
IN HSDB hSDB,
IN TAGREF trDriver,
OUT PSDBENTRYINFO pEntryInfo
);
DWORD
SDBAPI
SdbQueryData(
IN HSDB hSDB,
IN TAGREF trExe,
IN LPCTSTR lpszPolicyName, // if this is null, will try to return all the policy names
OUT LPDWORD lpdwDataType,
OUT LPVOID lpBuffer, // buffer to fill with information
IN OUT LPDWORD lpdwBufferSize
);
DWORD
SDBAPI
SdbQueryDataEx(
IN HSDB hSDB, // database handle
IN TAGREF trExe, // tagref of the matching exe
IN LPCTSTR lpszDataName, // if this is null, will try to return all the policy names
OUT LPDWORD lpdwDataType, // pointer to data type (REG_SZ, REG_BINARY, etc)
OUT LPVOID lpBuffer, // buffer to fill with information
IN OUT LPDWORD lpdwBufferSize, // pointer to buffer size
OUT TAGREF* ptrData // optional pointer to the retrieved data tag
);
DWORD
SdbQueryDataExTagID(
IN PDB pdb, // database handle
IN TAGID tiExe, // tagref of the matching exe
IN LPCTSTR lpszDataName, // if this is null, will try to return all the policy names
OUT LPDWORD lpdwDataType, // pointer to data type (REG_SZ, REG_BINARY, etc)
OUT LPVOID lpBuffer, // buffer to fill with information
IN OUT LPDWORD lpdwBufferSize, // pointer to buffer size
OUT TAGID* ptiData // optional pointer to the retrieved data tag
);
//
// Defines to keep kernel-mode code more readable
//
#define SdbQueryDriverInformation SdbQueryData
#define SdbReadDriverInformation SdbReadEntryInformation
#define SDBDRIVERINFO SDBENTRYINFO;
#define PSDBDRIVERINFO PSDBENTRYINFO;
//
// Query attribute APIs
//
PVOID
SdbGetFileInfo(
IN HSDB hSDB,
IN LPCTSTR pwszFilePath,
IN HANDLE hFile OPTIONAL,
IN LPVOID pImageBase OPTIONAL,
IN DWORD dwImageSize OPTIONAL,
IN BOOL bNoCache
);
VOID
SdbFreeFileInfo(
IN PVOID pFileInfo
);
//
// Get item from item ref
//
TAGREF
SdbGetItemFromItemRef(
IN HSDB hSDB,
IN TAGREF trItemRef,
IN TAG tagItemKey,
IN TAG tagItemTAGID,
IN TAG tagItem
);
#define SdbGetShimFromShimRef(hSDB, trShimRef) \
(SdbGetItemFromItemRef(hSDB, trShimRef, TAG_NAME, TAG_SHIM_TAGID, TAG_SHIM))
#define SdbGetPatchFromPatchRef(hSDB, trPatchRef) \
(SdbGetItemFromItemRef(hSDB, trPatchRef, TAG_NAME, TAG_PATCH_TAGID, TAG_PATCH))
#define SdbGetFlagFromFlagRef(hSDB, trFlagRef) \
(SdbGetItemFromItemRef(hSDB, trFlagRef, TAG_NAME, TAG_FLAG_TAGID, TAG_FLAG))
// INDEX functions
BOOL SdbDeclareIndex(
IN PDB pdb,
IN TAG tWhich,
IN TAG tKey,
IN DWORD dwEntries,
IN BOOL bUniqueKey,
OUT INDEXID* piiIndex
);
BOOL
SdbStartIndexing(
IN PDB pdb,
IN INDEXID iiWhich
);
BOOL
SdbStopIndexing(
IN PDB pdb,
IN INDEXID iiWhich
);
BOOL
SdbCommitIndexes(
IN PDB pdb
);
TAGID
SdbFindFirstDWORDIndexedTag(
IN PDB pdb,
IN TAG tWhich,
IN TAG tKey,
IN DWORD dwName,
OUT FIND_INFO* pFindInfo
);
TAGID
SdbFindNextDWORDIndexedTag(
IN PDB pdb,
OUT FIND_INFO* pFindInfo
);
TAGID
SdbFindFirstStringIndexedTag(
IN PDB pdb,
IN TAG tWhich,
IN TAG tKey,
IN LPCTSTR pwszName,
OUT FIND_INFO* pFindInfo
);
TAGID
SdbFindNextStringIndexedTag(
IN PDB pdb,
OUT FIND_INFO* pFindInfo
);
TAGID
SdbFindFirstGUIDIndexedTag(
IN PDB pdb,
IN TAG tWhich,
IN TAG tKey,
IN GUID* pGuidName,
OUT FIND_INFO* pFindInfo
);
TAGID
SdbFindNextGUIDIndexedTag(
IN PDB pdb,
OUT FIND_INFO* pFindInfo
);
ULONGLONG
SdbMakeIndexKeyFromString(
IN LPCTSTR pwszKey
);
//
// These macros allow to make a key from dword or a guid
//
#define MAKEKEYFROMDWORD(dwValue) \
((ULONGLONG)(dwValue))
#if defined(_WIN64)
ULONGLONG
SdbMakeIndexKeyFromGUID(
IN GUID* pGuid
);
#define MAKEKEYFROMGUID(pGuid) SdbMakeIndexKeyFromGUID(pGuid)
#else /* ! WIN64 */
#define MAKEKEYFROMGUID(pGuid) \
((ULONGLONG)((*(PULONGLONG)(pGuid)) ^ (*((PULONGLONG)(pGuid) + 1))))
#endif /* WIN64 */
TAGID
SdbGetIndex(
IN PDB pdb,
IN TAG tWhich,
IN TAG tKey,
OUT LPDWORD lpdwFlags OPTIONAL
);
#define SdbIsIndexAvailable(pdb, tWhich, tKey) \
(SdbGetIndex(pdb, tWhich, tKey, NULL))
//
// WRITE FUNCTIONS
//
TAGID
SdbBeginWriteListTag(
IN PDB pdb,
IN TAG tTag
);
BOOL
SdbEndWriteListTag(
IN PDB pdb,
IN TAGID tiList
);
BOOL
SdbWriteStringTagDirect(
IN PDB pdb,
IN TAG tTag,
IN LPCWSTR pwszData
);
BOOL
SdbWriteStringRefTag(
IN PDB pdb,
IN TAG tTag,
IN STRINGREF srData
);
BOOL
SdbWriteNULLTag(
IN PDB pdb,
IN TAG tTag
);
BOOL
SdbWriteBYTETag(
IN PDB pdb,
IN TAG tTag,
IN BYTE jData
);
BOOL
SdbWriteWORDTag(
IN PDB pdb,
IN TAG tTag,
IN WORD wData
);
BOOL
SdbWriteDWORDTag(
IN PDB pdb,
IN TAG tTag,
IN DWORD dwData
);
BOOL
SdbWriteQWORDTag(
IN PDB pdb,
IN TAG tTag,
IN ULONGLONG qwData
);
BOOL
SdbWriteStringTag(
IN PDB pdb,
IN TAG tTag,
IN LPCWSTR pwszData
);
BOOL
SdbWriteBinaryTag(
IN PDB pdb,
IN TAG tTag,
IN PBYTE pBuffer,
IN DWORD dwSize
);
BOOL
SdbWriteBinaryTagFromFile(
IN PDB pdb,
IN TAG tTag,
IN LPCWSTR pwszPath
);
////////////////////////////////////////////////////////////////////////////////////////////
//
// Attribute retrieval
//
//
//
// Attribute Information
// identified by a tag
//
//
typedef struct tagATTRINFO {
TAG tAttrID; // tag for this attribute (includes type)
DWORD dwFlags; // flags : such as "not avail" or "not there yet"
union { // anonymous union with values
ULONGLONG ullAttr; // QWORD value (TAG_TYPE_QWORD)
DWORD dwAttr; // DWORD value (TAG_TYPE_DWORD)
TCHAR* lpAttr; // WCHAR* value (TAG_TYPE_STRINGREF)
};
} ATTRINFO, *PATTRINFO;
//
// Flags that go into ATTRINFO's dwFlags field
//
//
#define ATTRIBUTE_AVAILABLE 0x00000001 // this will be set if attribute was obtained
#define ATTRIBUTE_FAILED 0x00000002 // this will be set if we tried to get it
// and failed
BOOL
SDBAPI
SdbGetFileAttributes(
IN LPCTSTR lpwszFileName,
OUT PATTRINFO* ppAttrInfo,
OUT LPDWORD lpdwAttrCount);
BOOL
SDBAPI
SdbFreeFileAttributes(
IN PATTRINFO pFileAttributes);
BOOL
SDBAPI
SdbFormatAttribute(
IN PATTRINFO pAttrInfo,
OUT LPTSTR pchBuffer,
IN DWORD dwBufferSize);
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// High-level functions to extract information related to apphelp
//
//
typedef struct tagAPPHELP_DATA {
DWORD dwFlags; // flags (if any)
DWORD dwSeverity; // can be none APPTYPE_NONE (0)
DWORD dwHTMLHelpID; // help id
LPTSTR szAppName;
TAGREF trExe; // matched on this exe (in apphelp section)
LPTSTR szURL; // URL
LPTSTR szLink; // link text
LPTSTR szAppTitle; // title
LPTSTR szContact; // contact info
LPTSTR szDetails; // details
//
// non-apphelp data (this is managed by the host app
//
DWORD dwData;
BOOL bSPEntry; // TRUE if this entry is in apph_sp.sdb
} APPHELP_DATA, *PAPPHELP_DATA;
BOOL
SdbReadApphelpData(
IN HSDB hSDB,
IN TAGREF trExe,
OUT PAPPHELP_DATA pData
);
BOOL
SdbReadApphelpDetailsData(
IN PDB pdbDetails,
OUT PAPPHELP_DATA pData
);
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// A few functions from apphelp.dll
//
//
BOOL
SDBAPI
SetPermLayers(
IN LPCWSTR pwszPath, // path to the file to set a permanent layer on
IN LPCWSTR pwszLayers, // layers to apply to the file, separated by spaces
IN BOOL bMachine // TRUE if the layers should be persisted per machine
);
BOOL
SDBAPI
GetPermLayers(
IN LPCWSTR pwszPath, // path to the file to set a permanent layer on
OUT LPWSTR pwszLayers, // layers to apply to the file, separated by spaces
OUT DWORD* pdwBytes, // input: number of bytes available; output is number of bytes needed
IN DWORD dwFlags
);
BOOL
SDBAPI
AllowPermLayer(
IN LPCWSTR pwszPath // path to the file to check whether you can set a permanent layer on
);
typedef struct _NTVDM_FLAGS {
DWORD dwWOWCompatFlags;
DWORD dwWOWCompatFlagsEx;
DWORD dwUserWOWCompatFlags;
DWORD dwWOWCompatFlags2;
DWORD dwWOWCompatFlagsFE;
DWORD dwFlagsInfoSize; // size of the memory area pointed to by pFlagsInfo
PVOID pFlagsInfo; // pointer that is used to store flags-related information
} NTVDM_FLAGS, *PNTVDM_FLAGS;
//
// Macros we use to obtain flags command lines
//
#define MAKEQWORD(dwLow, dwHigh) \
( ((ULONGLONG)(dwLow)) | ( ((ULONGLONG)(dwHigh)) << 32) )
#define GET_WOWCOMPATFLAGS_CMDLINE(pFlagInfo, dwFlag, ppCmdLine) \
SdbQueryFlagInfo(pFlagInfo, TAG_FLAGS_NTVDM1, MAKEQWORD(dwFlag, 0), ppCmdLine)
#define GET_WOWCOMPATFLAGSEX_CMDLINE(pFlagInfo, dwFlag, ppCmdLine) \
SdbQueryFlagInfo(pFlagInfo, TAG_FLAGS_NTVDM1, MAKEQWORD(0, dwFlag), ppCmdLine)
#define GET_USERWOWCOMPATFLAGS_CMDLINE(pFlagInfo, dwFlag, ppCmdLine) \
SdbQueryFlagInfo(pFlagInfo, TAG_FLAGS_NTVDM2, MAKEQWORD(dwFlag, 0), ppCmdLine)
#define GET_WOWCOMPATFLAGS2_CMDLINE(pFlagInfo, dwFlag, ppCmdLine) \
SdbQueryFlagInfo(pFlagInfo, TAG_FLAGS_NTVDM2, MAKEQWORD(0, dwFlag), ppCmdLine)
#define GET_WOWCOMPATFLAGSFE_CMDLINE(pFlagInfo, dwFlag, ppCmdLine) \
SdbQueryFlagInfo(pFlagInfo, TAG_FLAGS_NTVDM3, MAKEQWORD(dwFlag, 0), ppCmdLine)
typedef struct _APPHELP_INFO {
//
// html help id mode
//
DWORD dwHtmlHelpID; // html help id
DWORD dwSeverity; // must have
LPCTSTR lpszAppName;
GUID guidID; // entry guid
//
// Conventional mode
//
TAGID tiExe; // the TAGID of the exe entry within the DB
GUID guidDB; // the guid of the DB that has the EXE entry
BOOL bOfflineContent;
BOOL bUseHTMLHelp;
LPCTSTR lpszChmFile;
LPCTSTR lpszDetailsFile;
//
// preserve users choice on the dialog if user chooses to persist settings
//
BOOL bPreserveChoice;
} APPHELP_INFO, *PAPPHELP_INFO;
////////////////////////////////////////////////////////////////////////////////////////////
//
//
// Functions to access apphelp functionality
//
//
BOOL
ApphelpGetNTVDMInfo(
IN LPCWSTR pwszPath, // path to the app in NT format
IN LPCWSTR pwszModule, // module name
IN LPCWSTR pEnvironment, // pointer to the environment of the task that is
// being created or NULL if we are to use the main NTVDM
// environment block.
OUT LPWSTR pszCompatLayer, // The new compat layer variable. with format:
// "Alpha Bravo Charlie" -- allow 256 chars for this.
OUT PNTVDM_FLAGS pFlags, // The flags
OUT PAPPHELP_INFO pAHInfo // If there is apphelp to display, this will be filled
// in with non-null values
);
BOOL
ApphelpShowDialog(
IN PAPPHELP_INFO pAHInfo, // the info necessary to find the apphelp data
IN PHANDLE phProcess // [optional] returns the process handle of
// the process displaying the apphelp.
// When the process completes, the return value
// (from GetExitCodeProcess()) will be zero
// if the app should not run, or non-zero
// if it should run.
);
typedef PVOID HAPPHELPINFOCONTEXT;
typedef enum tagAPPHELPINFORMATIONCLASS {
ApphelpFlags,
ApphelpExeName,
ApphelpAppName,
ApphelpVendorName,
ApphelpHtmlHelpID,
ApphelpProblemSeverity,
ApphelpLinkURL,
ApphelpLinkText,
ApphelpTitle,
ApphelpDetails,
ApphelpContact,
ApphelpHelpCenterURL,
ApphelpExeTagID,
ApphelpDatabaseGUID // this is guid of a database containing the match
} APPHELPINFORMATIONCLASS;
PDB
SDBAPI
SdbOpenApphelpDetailsDatabase(
IN LPCWSTR pwsDetailsDatabasePath OPTIONAL
);
PDB
SDBAPI
SdbOpenApphelpDetailsDatabaseSP(
void
);
HAPPHELPINFOCONTEXT
SDBAPI
SdbOpenApphelpInformation(
IN GUID* pguidDB,
IN GUID* pguidID
);
HAPPHELPINFOCONTEXT
SDBAPI
SdbOpenApphelpInformationByID(
IN HSDB hSDB,
IN TAGREF trEntry,
IN DWORD dwDatabaseType // pass the type of db you are using
);
BOOL
SDBAPI
SdbCloseApphelpInformation(
IN HAPPHELPINFOCONTEXT hctx
);
DWORD
SDBAPI
SdbQueryApphelpInformation(
IN HAPPHELPINFOCONTEXT hctx,
IN APPHELPINFORMATIONCLASS InfoClass,
OUT LPVOID pBuffer, // may be NULL
IN DWORD cbSize // may be 0 if pBuffer is NULL
);
BOOL
SDBAPI
SdbQueryFlagMask(
IN HSDB hSDB,
IN SDBQUERYRESULT* pQueryResult,
IN TAG tMaskType,
OUT ULONGLONG* pullFlags,
IN OUT PVOID* ppFlagInfo OPTIONAL
);
BOOL
SDBAPI
SdbEscapeApphelpURL(
OUT LPWSTR szResult, // escaped string (output)
IN OUT LPDWORD pdwCount, // count of tchars in the buffer pointed to by szResult
IN LPCWSTR szToEscape // string to escape
);
BOOL
SDBAPI
SdbSetApphelpDebugParameters(
IN HAPPHELPINFOCONTEXT hctx,
IN LPCWSTR pszDetailsDatabase OPTIONAL,
IN BOOL bOfflineContent OPTIONAL, // pass FALSE
IN BOOL bUseHtmlHelp OPTIONAL, // pass FALSE
IN LPCWSTR pszChmFile OPTIONAL // pass NULL
);
BOOL
SdbShowApphelpDialog( // returns TRUE if success, whether we should run the app is in pRunApp
IN PAPPHELP_INFO pAHInfo, // the info necessary to find the apphelp data
OUT PHANDLE phProcess, // [optional] returns the process handle of
// the process displaying the apphelp.
// When the process completes, the return value
// (from GetExitCodeProcess()) will be zero
// if the app should not run, or non-zero
// if it should run.
IN OUT BOOL* pRunApp
);
//
// WOW cmd line for flags interface
// instead of calling SdbQueryFlagInfo the macros above should be used
//
BOOL
SDBAPI
SdbQueryFlagInfo(
IN PVOID pvFlagInfo,
IN TAG tFlagType,
IN ULONGLONG ullFlagMask,
OUT LPCTSTR * ppCmdLine
);
BOOL
SDBAPI
SdbFreeFlagInfo(
IN PVOID pvFlagInfo
);
////////////////////////////////////////////////////////////////////////////////////////////
//
// App Verifier macros/defs
//
//
typedef enum _VLOG_LEVEL {
VLOG_LEVEL_INFO,
VLOG_LEVEL_WARNING,
VLOG_LEVEL_ERROR
} VLOG_LEVEL, *PVLOG_LEVEL;
typedef enum _AVRF_INFO_ID {
// INFO ID type actually being passed in PVOID param
// ------- -----------------------------------------
AVRF_INFO_NUM_SHIMS, // LPDWORD (preallocated) (szName should be NULL)
AVRF_INFO_SHIM_NAMES, // LPWSTR * (array of same size as value of AVRF_INFO_NUM_SHIMS)
// (array is preallocated, strings are allocated by shim)
// (szName should be NULL)
AVRF_INFO_DESCRIPTION, // LPWSTR (allocated by shim)
AVRF_INFO_FRIENDLY_NAME, // LPWSTR (allocated by shim)
AVRF_INFO_INCLUDE_EXCLUDE, // LPWSTR (allocated by shim)
AVRF_INFO_FLAGS, // LPDWORD (preallocated)
AVRF_INFO_OPTIONS_PAGE, // LPPROPSHEETPAGE (preallocated)
AVRF_INFO_VERSION, // LPDWORD (preallocated), HIWORD=major version, LOWORD=minor version
AVRF_INFO_GROUPS // LPDWORD (preallocated)
} AVRF_INFO_ID, *PAVRF_INFO_ID;
//
// FLAGS for verifier shims (all flags default to FALSE)
//
#define AVRF_FLAG_NO_DEFAULT 0x00000001 // this shim should not be turned on by default
#define AVRF_FLAG_NO_WIN2K 0x00000002 // this shim should not be used on win2K
#define AVRF_FLAG_NO_SHIM 0x00000004 // this "shim" is a placeholder and shouldn't actually
// be applied to an app
#define AVRF_FLAG_NO_TEST 0x00000008 // this "shim" is not a test, and is purely for adding
// a page to the options dialog
#define AVRF_FLAG_NOT_SETUP 0x00000010 // this shim is not appropriate for setup apps
#define AVRF_FLAG_ONLY_SETUP 0x00000020 // this shim is only appropriate for setup apps
#define AVRF_FLAG_RUN_ALONE 0x00000040 // this shim should be run by itself with no other shims applied
//
// GROUPS for verifier shims (by default, shims are in no groups)
//
#define AVRF_GROUP_SETUP 0x00000001 // suitable for checking setup programs
#define AVRF_GROUP_NON_SETUP 0x00000002 // suitable for checking non-setup programs (can be both)
#define AVRF_GROUP_LOGO 0x00000004 // shims that are useful for logo testing
//
// magic number tells us if we're using the same shim interface
//
#define VERIFIER_SHIMS_MAGIC 'avfr'
typedef DWORD (*_pfnGetVerifierMagic)(void);
typedef BOOL (*_pfnQueryShimInfo)(LPCWSTR szName, AVRF_INFO_ID eInfo, PVOID pInfo);
//
// special callback, so a shim can be notified when it is activated or deactivated for a
// specific application.
//
typedef BOOL (*_pfnActivateCallback)(LPCWSTR szAppName, BOOL bActivate);
//
// Where we store default verifier shim settings
//
#define AVRF_DEFAULT_SETTINGS_NAME TEXT("{default}")
#define AVRF_DEFAULT_SETTINGS_NAME_W L"{default}"
#define AVRF_DEFAULT_SETTINGS_NAME_A "{default}"
typedef struct _SHIM_DESCRIPTION {
LPWSTR szName;
LPWSTR szDescription;
LPWSTR szExcludes; // comma separated module names
LPWSTR szIncludes; // comma separated module names
DWORD dwFlags;
} SHIM_DESCRIPTION, *PSHIM_DESCRIPTION;
#define ENUM_SHIMS_MAGIC 'enum'
typedef DWORD (*_pfnEnumShims)(PSHIM_DESCRIPTION pShims, DWORD dwMagic);
typedef BOOL (*_pfnIsVerifierDLL)(void);
////////////////////////////////////////////////////////////////////////////////////////////
//
// Miscelaneous macros/defs
//
//
//
// Match modes for EXEs
//
#define MATCH_NORMAL 0
#define MATCH_EXCLUSIVE 1
#define MATCH_ADDITIVE 2
//
// the struct below packs into a WORD
// older compilers won't like this union
// (because of nameless members)
//
typedef union tagMATCHMODE {
struct {
USHORT Type : 4; // type of match
USHORT Flags: 4; // flags for matching
// future expansion here
};
WORD wMatchMode; // we use this to init from the database
DWORD dwMatchMode; // this is the "whole" match mode
} MATCHMODE, *PMATCHMODE;
//
// match modes:
//
// normal -- find a match, we're done
// additive -- keep the match, then keep matching according to flags
// exclusive -- keep the match, throw away all other matches
//
static const MATCHMODE MatchModeDefaultMain = { { MATCH_NORMAL, 0 } };
#define MATCHMODE_DEFAULT_MAIN (MatchModeDefaultMain.wMatchMode)
static const MATCHMODE MatchModeDefaultCustom = { { MATCH_ADDITIVE, 0 } };
#define MATCHMODE_DEFAULT_CUSTOM (MatchModeDefaultCustom.wMatchMode)
#define MAKE_MATCHMODE(dwMatchMode, Type, Flags) \
{ \
((PMATCHMODE)&(dwMatchMode))->Type = Type; \
((PMATCHMODE)&(dwMatchMode))->Flags = Flags; \
}
//
// Pre-defined match modes for shimdbc
//
static const MATCHMODE MatchModeNormal = { { MATCH_NORMAL, 0 } };
static const MATCHMODE MatchModeAdditive = { { MATCH_ADDITIVE, 0 } };
static const MATCHMODE MatchModeExclusive = { { MATCH_EXCLUSIVE, 0 } };
#define MATCHMODE_NORMAL_SHIMDBC (MatchModeNormal.wMatchMode)
#define MATCHMODE_ADDITIVE_SHIMDBC (MatchModeAdditive.wMatchMode)
#define MATCHMODE_EXCLUSIVE_SHIMDBC (MatchModeExclusive.wMatchMode)
//
// Runtime platform flags
//
#define RUNTIME_PLATFORM_FLAG_NOT 0x80000000
#define RUNTIME_PLATFORM_FLAG_NOT_ELEMENT 0x00000080
#define RUNTIME_PLATFORM_FLAG_VALID 0x00000040
#define RUNTIME_PLATFORM_MASK_ELEMENT 0x000000FF
#define RUNTIME_PLATFORM_MASK_VALUE 0x0000003F
#define RUNTIME_PLATFORM_ANY 0xC0000000 // no valid bits + NOT + flag
//
// Shimdbc compile-time platform (OS_PLATFORM) flags
//
#define OS_PLATFORM_NONE 0x00000000
#define OS_PLATFORM_I386 0x00000001
#define OS_PLATFORM_IA64 0x00000002
#define OS_PLATFORM_ALL 0xFFFFFFFF
//
// These definitions are used for OS SKU attribute tags on EXE entries
//
#define OS_SKU_NONE 0x00000000 // None
#define OS_SKU_PER 0x00000001 // Personal
#define OS_SKU_PRO 0x00000002 // Professional
#define OS_SKU_SRV 0x00000004 // Server
#define OS_SKU_ADS 0x00000008 // Advanced Server
#define OS_SKU_DTC 0x00000010 // Datacenter
#define OS_SKU_BLA 0x00000020 // Blade Server
#define OS_SKU_TAB 0x00000040 // TabletPC
#define OS_SKU_MED 0x00000080 // eHome
#define OS_SKU_ALL 0xFFFFFFFF
#ifndef ARRAYSIZE
#define ARRAYSIZE(rg) (sizeof(rg)/sizeof((rg)[0]))
#endif
#ifndef OFFSETOF
#define OFFSETOF offsetof
#endif
#define CHARCOUNT(sz) (sizeof(sz) / sizeof(sz[0]))
//
// our reg key locations
//
#define APPCOMPAT_LOCATION TEXT("Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags")
#define APPCOMPAT_KEY_PATH APPCOMPAT_LOCATION
#define APPCOMPAT_KEY_PATH_CUSTOM APPCOMPAT_LOCATION TEXT("\\Custom")
#define APPCOMPAT_KEY_PATH_INSTALLEDSDB APPCOMPAT_LOCATION TEXT("\\InstalledSDB")
#define POLICY_KEY_APPCOMPAT TEXT("Software\\Policies\\Microsoft\\Windows\\AppCompat")
#define POLICY_VALUE_DISABLE_ENGINE TEXT("DisableEngine")
#define POLICY_VALUE_DISABLE_WIZARD TEXT("DisableWizard")
#define POLICY_VALUE_DISABLE_PROPPAGE TEXT("DisablePropPage")
#define POLICY_VALUE_APPHELP_LOG TEXT("LogAppHelpEvents")
// NT API versions
#define APPCOMPAT_KEY_PATH_MACHINE TEXT("\\Registry\\Machine\\") APPCOMPAT_LOCATION
#define APPCOMPAT_KEY_PATH_NT TEXT("\\") APPCOMPAT_LOCATION
#define APPCOMPAT_PERM_LAYER_PATH TEXT("\\") APPCOMPAT_LOCATION TEXT("\\Layers")
#define APPCOMPAT_KEY_PATH_MACHINE_CUSTOM APPCOMPAT_KEY_PATH_MACHINE TEXT("\\Custom")
#define APPCOMPAT_KEY_PATH_MACHINE_INSTALLEDSDB APPCOMPAT_KEY_PATH_MACHINE TEXT("\\InstalledSDB")
//
// our reg key locations
//
#define POLICY_VALUE_APPHELP_LOG_A "LogAppHelpEvents"
//
// our reg key locations
//
#define APPCOMPAT_LOCATION_W L"Software\\Microsoft\\Windows NT\\CurrentVersion\\AppCompatFlags"
#define APPCOMPAT_KEY_PATH_W APPCOMPAT_LOCATION_W
#define APPCOMPAT_KEY_PATH_CUSTOM_W APPCOMPAT_LOCATION_W L"\\Custom"
#define APPCOMPAT_KEY_PATH_INSTALLEDSDB_W APPCOMPAT_LOCATION_W L"\\InstalledSDB"
#define POLICY_KEY_APPCOMPAT_W L"Software\\Policies\\Microsoft\\Windows\\AppCompat"
#define POLICY_VALUE_DISABLE_ENGINE_W L"DisableEngine"
#define POLICY_VALUE_DISABLE_WIZARD_W L"DisableWizard"
#define POLICY_VALUE_DISABLE_PROPPAGE_W L"DisablePropPage"
#define POLICY_VALUE_APPHELP_LOG_W L"LogAppHelpEvents"
//
// LUA all-users redirection location
//
#define LUA_REDIR ("%ALLUSERSPROFILE%\\Application Data\\Redirected")
#define LUA_REDIR_W TEXT("%ALLUSERSPROFILE%\\Application Data\\Redirected")
//
// debug output support
//
typedef enum tagSHIMDBGLEVEL {
sdlError = 1,
sdlWarning = 2,
sdlFail = 1, // this means we have failed some api, not necessarily fatal
sdlInfo = 3,
sdlUser = 4
} SHIMDBGLEVEL;
//
// This flag marks the debug out for pipe
//
#define sdlLogPipe 0x00000080UL
#define sdlMask 0x0000007FUL
#define FILTER_DBG_LEVEL(level) ((int)((level) & sdlMask))
extern int __cdecl ShimDbgPrint(INT iDebugLevel, PCH FunctionName, PCH Format, ...);
#if DBG // Define _DEBUG_SPEW when compiling checked
#ifndef _DEBUG_SPEW
#define _DEBUG_SPEW
#endif
#endif // DBG
#ifdef _DEBUG_SPEW
//
// This value is a large number (initiallly)
// We will initialize it from the environment upon the first call
// to ShimDbgPrint
//
extern int g_iShimDebugLevel;
#define DBGPRINT( _x_ ) \
{ \
if (g_iShimDebugLevel) { \
ShimDbgPrint _x_; \
} \
}
#else
#define DBGPRINT(_x_)
#endif // _DEBUG_SPEW
///////////////////////////////////////////////////////////////////////////////
//
// SHIM TAGS
//
//
// Function to get the tag names given a tag ID.
//
// WARNING !!! : If you add new tags make sure you update SdbApi\attributes.c
// with the name of the tag in the global gaTagInfo.
//
LPCTSTR
SDBAPI
SdbTagToString(
TAG tag
);
//
// LIST types for shimdb
//
#define TAG_DATABASE (0x1 | TAG_TYPE_LIST)
#define TAG_LIBRARY (0x2 | TAG_TYPE_LIST)
#define TAG_INEXCLUDE (0x3 | TAG_TYPE_LIST)
#define TAG_SHIM (0x4 | TAG_TYPE_LIST)
#define TAG_PATCH (0x5 | TAG_TYPE_LIST)
#define TAG_APP (0x6 | TAG_TYPE_LIST)
#define TAG_EXE (0x7 | TAG_TYPE_LIST)
#define TAG_MATCHING_FILE (0x8 | TAG_TYPE_LIST)
#define TAG_SHIM_REF (0x9 | TAG_TYPE_LIST)
#define TAG_PATCH_REF (0xA | TAG_TYPE_LIST)
#define TAG_LAYER (0xB | TAG_TYPE_LIST)
#define TAG_FILE (0xC | TAG_TYPE_LIST)
#define TAG_APPHELP (0xD | TAG_TYPE_LIST)
#define TAG_LINK (0xE | TAG_TYPE_LIST) // Description list w/lang ids and urls
#define TAG_DATA (0xF | TAG_TYPE_LIST)
#define TAG_MSI_TRANSFORM (0x10| TAG_TYPE_LIST)
#define TAG_MSI_TRANSFORM_REF (0x11| TAG_TYPE_LIST)
#define TAG_MSI_PACKAGE (0x12| TAG_TYPE_LIST)
#define TAG_FLAG (0x13| TAG_TYPE_LIST)
#define TAG_MSI_CUSTOM_ACTION (0x14| TAG_TYPE_LIST)
#define TAG_FLAG_REF (0x15| TAG_TYPE_LIST)
#define TAG_ACTION (0x16| TAG_TYPE_LIST)
//
// STRINGREF types for shimdb
//
#define TAG_NAME (0x1 | TAG_TYPE_STRINGREF)
#define TAG_DESCRIPTION (0x2 | TAG_TYPE_STRINGREF)
#define TAG_MODULE (0x3 | TAG_TYPE_STRINGREF)
#define TAG_API (0x4 | TAG_TYPE_STRINGREF)
#define TAG_VENDOR (0x5 | TAG_TYPE_STRINGREF)
#define TAG_APP_NAME (0x6 | TAG_TYPE_STRINGREF)
#define TAG_COMMAND_LINE (0x8 | TAG_TYPE_STRINGREF)
#define TAG_COMPANY_NAME (0x9 | TAG_TYPE_STRINGREF)
#define TAG_DLLFILE (0xA | TAG_TYPE_STRINGREF)
#define TAG_WILDCARD_NAME (0xB | TAG_TYPE_STRINGREF)
#define TAG_PRODUCT_NAME (0x10 | TAG_TYPE_STRINGREF)
#define TAG_PRODUCT_VERSION (0x11 | TAG_TYPE_STRINGREF)
#define TAG_FILE_DESCRIPTION (0x12 | TAG_TYPE_STRINGREF)
#define TAG_FILE_VERSION (0x13 | TAG_TYPE_STRINGREF)
#define TAG_ORIGINAL_FILENAME (0x14 | TAG_TYPE_STRINGREF)
#define TAG_INTERNAL_NAME (0x15 | TAG_TYPE_STRINGREF)
#define TAG_LEGAL_COPYRIGHT (0x16 | TAG_TYPE_STRINGREF)
#define TAG_16BIT_DESCRIPTION (0x17 | TAG_TYPE_STRINGREF)
#define TAG_APPHELP_DETAILS (0x18 | TAG_TYPE_STRINGREF) // Details in single language
#define TAG_LINK_URL (0x19 | TAG_TYPE_STRINGREF)
#define TAG_LINK_TEXT (0x1A | TAG_TYPE_STRINGREF)
#define TAG_APPHELP_TITLE (0x1B | TAG_TYPE_STRINGREF)
#define TAG_APPHELP_CONTACT (0x1C | TAG_TYPE_STRINGREF)
#define TAG_SXS_MANIFEST (0x1D | TAG_TYPE_STRINGREF)
#define TAG_DATA_STRING (0x1E | TAG_TYPE_STRINGREF)
#define TAG_MSI_TRANSFORM_FILE (0x1F | TAG_TYPE_STRINGREF)
#define TAG_16BIT_MODULE_NAME (0x20 | TAG_TYPE_STRINGREF)
#define TAG_LAYER_DISPLAYNAME (0x21 | TAG_TYPE_STRINGREF)
#define TAG_COMPILER_VERSION (0x22 | TAG_TYPE_STRINGREF)
#define TAG_ACTION_TYPE (0x23 | TAG_TYPE_STRINGREF)
#define TAG_STRINGTABLE (0x801 | TAG_TYPE_LIST)
//
// DWORD types for shimdb
//
#define TAG_SIZE (0x1 | TAG_TYPE_DWORD)
#define TAG_OFFSET (0x2 | TAG_TYPE_DWORD)
#define TAG_CHECKSUM (0x3 | TAG_TYPE_DWORD)
#define TAG_SHIM_TAGID (0x4 | TAG_TYPE_DWORD)
#define TAG_PATCH_TAGID (0x5 | TAG_TYPE_DWORD)
#define TAG_MODULE_TYPE (0x6 | TAG_TYPE_DWORD)
#define TAG_VERDATEHI (0x7 | TAG_TYPE_DWORD)
#define TAG_VERDATELO (0x8 | TAG_TYPE_DWORD)
#define TAG_VERFILEOS (0x9 | TAG_TYPE_DWORD)
#define TAG_VERFILETYPE (0xA | TAG_TYPE_DWORD)
#define TAG_PE_CHECKSUM (0xB | TAG_TYPE_DWORD)
#define TAG_PREVOSMAJORVER (0xC | TAG_TYPE_DWORD)
#define TAG_PREVOSMINORVER (0xD | TAG_TYPE_DWORD)
#define TAG_PREVOSPLATFORMID (0xE | TAG_TYPE_DWORD)
#define TAG_PREVOSBUILDNO (0xF | TAG_TYPE_DWORD)
#define TAG_PROBLEMSEVERITY (0x10 | TAG_TYPE_DWORD)
#define TAG_LANGID (0x11 | TAG_TYPE_DWORD)
#define TAG_VER_LANGUAGE (0x12 | TAG_TYPE_DWORD)
#define TAG_ENGINE (0x14 | TAG_TYPE_DWORD)
#define TAG_HTMLHELPID (0x15 | TAG_TYPE_DWORD)
#define TAG_INDEX_FLAGS (0x16 | TAG_TYPE_DWORD)
#define TAG_FLAGS (0x17 | TAG_TYPE_DWORD)
#define TAG_DATA_VALUETYPE (0x18 | TAG_TYPE_DWORD)
#define TAG_DATA_DWORD (0x19 | TAG_TYPE_DWORD)
#define TAG_LAYER_TAGID (0x1A | TAG_TYPE_DWORD)
#define TAG_MSI_TRANSFORM_TAGID (0x1B | TAG_TYPE_DWORD)
#define TAG_LINKER_VERSION (0x1C | TAG_TYPE_DWORD)
#define TAG_LINK_DATE (0x1D | TAG_TYPE_DWORD)
#define TAG_UPTO_LINK_DATE (0x1E | TAG_TYPE_DWORD)
#define TAG_OS_SERVICE_PACK (0x1F | TAG_TYPE_DWORD)
#define TAG_FLAG_TAGID (0x20 | TAG_TYPE_DWORD)
#define TAG_RUNTIME_PLATFORM (0x21 | TAG_TYPE_DWORD)
#define TAG_OS_SKU (0x22 | TAG_TYPE_DWORD)
#define TAG_TAGID (0x801| TAG_TYPE_DWORD)
//
// STRING types
//
#define TAG_STRINGTABLE_ITEM (0x801 | TAG_TYPE_STRING)
//
// NULL types for shimdb (existence/nonexistence is treated like a BOOL)
//
#define TAG_INCLUDE (0x1 | TAG_TYPE_NULL)
#define TAG_GENERAL (0x2 | TAG_TYPE_NULL)
#define TAG_MATCH_LOGIC_NOT (0x3 | TAG_TYPE_NULL)
#define TAG_APPLY_ALL_SHIMS (0x4 | TAG_TYPE_NULL)
#define TAG_USE_SERVICE_PACK_FILES (0x5 | TAG_TYPE_NULL)
//
// QWORD types for shimdb
//
#define TAG_TIME (0x1 | TAG_TYPE_QWORD)
#define TAG_BIN_FILE_VERSION (0x2 | TAG_TYPE_QWORD)
#define TAG_BIN_PRODUCT_VERSION (0x3 | TAG_TYPE_QWORD)
#define TAG_MODTIME (0x4 | TAG_TYPE_QWORD)
#define TAG_FLAG_MASK_KERNEL (0x5 | TAG_TYPE_QWORD)
#define TAG_UPTO_BIN_PRODUCT_VERSION (0x6 | TAG_TYPE_QWORD)
#define TAG_DATA_QWORD (0x7 | TAG_TYPE_QWORD)
#define TAG_FLAG_MASK_USER (0x8 | TAG_TYPE_QWORD)
#define TAG_FLAGS_NTVDM1 (0x9 | TAG_TYPE_QWORD)
#define TAG_FLAGS_NTVDM2 (0xA | TAG_TYPE_QWORD)
#define TAG_FLAGS_NTVDM3 (0xB | TAG_TYPE_QWORD)
#define TAG_FLAG_MASK_SHELL (0xC | TAG_TYPE_QWORD)
#define TAG_UPTO_BIN_FILE_VERSION (0xD | TAG_TYPE_QWORD)
//
// BINARY types for shimdb
//
#define TAG_PATCH_BITS (0x2 | TAG_TYPE_BINARY)
#define TAG_FILE_BITS (0x3 | TAG_TYPE_BINARY)
#define TAG_EXE_ID (0x4 | TAG_TYPE_BINARY)
#define TAG_DATA_BITS (0x5 | TAG_TYPE_BINARY)
#define TAG_MSI_PACKAGE_ID (0x6 | TAG_TYPE_BINARY) // msi package id is a guid
#define TAG_DATABASE_ID (0x7 | TAG_TYPE_BINARY) // database guid
#define TAG_INDEX_BITS (0x801 | TAG_TYPE_BINARY)
//
// INDEX types for shimdb
//
#define TAG_INDEXES (0x802 | TAG_TYPE_LIST)
#define TAG_INDEX (0x803 | TAG_TYPE_LIST)
//
// WORD types
//
#define TAG_MATCH_MODE (0x1 | TAG_TYPE_WORD)
#define TAG_TAG (0x801 | TAG_TYPE_WORD)
#define TAG_INDEX_TAG (0x802 | TAG_TYPE_WORD)
#define TAG_INDEX_KEY (0x803 | TAG_TYPE_WORD)
//
// let the typedefs take the course..
//
#undef LPCTSTR
#undef LPTSTR
#undef TCHAR
#endif // _SHIMDB_H_
Reference in a new issue Copy permalink