windows-xp/Source/XPSP1/NT/windows/appcompat/sdbapi/sdbp.h

#ifndef __SDBP_H__
#define __SDBP_H__

#ifndef SDB_ANSI_LIB
    #define UNICODE
    #define _UNICODE
#endif

#include <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <malloc.h>
#include <stddef.h>

#ifndef KERNEL_MODE

    #include <nt.h>
    #include <ntrtl.h>
    #include <nturtl.h>

    #include <windows.h>

#else // KERNEL_MODE

    #include <ntosp.h>
    #include <zwapi.h>

    #include <ntimage.h>
    #include <windef.h>
    #include <winver.h>
    #include <winerror.h>
    #include <stdarg.h>
    #include <ntldr.h>

    #define NtCreateFile           ZwCreateFile
    #define NtClose                ZwClose
    #define NtReadFile             ZwReadFile
    #define NtOpenKey              ZwOpenKey
    #define NtQueryValueKey        ZwQueryValueKey
    #define NtMapViewOfSection     ZwMapViewOfSection
    #define NtUnmapViewOfSection   ZwUnmapViewOfSection
    #define NtOpenFile             ZwOpenFile
    #define NtQueryInformationFile ZwQueryInformationFile

    #ifndef MAKEINTRESOURCE
        #define MAKEINTRESOURCEW(i) (LPWSTR)((ULONG_PTR)((WORD)(i)))
        #define MAKEINTRESOURCE MAKEINTRESOURCEW
    #endif // not defined MAKEINTRESOURCE

    #ifndef RT_VERSION
        #define RT_VERSION  MAKEINTRESOURCE(16)
    #endif // not defined RT_VERSION

    #ifndef INVALID_HANDLE_VALUE
        #define INVALID_HANDLE_VALUE ((HANDLE)(LONG_PTR)-1)
    #endif // not defined INVALID_HANDLE_VALUE

    #ifndef SEC_COMMIT
        #define SEC_COMMIT  0x8000000
    #endif

#endif // KERNEL_MODE


#include <tchar.h>

#include "shimdb.h"

#define MAX_INDEXES             10

#define TABLETPC_KEY_PATH   TEXT("System\\WPA\\TabletPC")
#define EHOME_KEY_PATH      TEXT("SYSTEM\\WPA\\MediaCenter")
#define IS_OS_INSTALL_VALUE TEXT("Installed")

//
// This is a flag stored for each index.
// Currently it is only used to flag "unique key" types.
//
#define SHIMDB_INDEX_UNIQUE_KEY 0x00000001



// index could be of 2 types:
// containing simply all record and containing only
// "unique" keys with the records linked (the records have to be sorted for this
// type of index to work)
typedef struct _INDEX_INFO {
    TAGID       tiIndex;            // points at the INDEX_BITS tag
    TAG         tWhich;             // what tag is being indexed
    TAG         tKey;               // what subtag is the key?
    BOOL        bActive;            // are we actually indexing now?
    BOOL        bUniqueKey;         // are the keys unique?
    ULONGLONG   ullLastKey;
    DWORD       dwIndexEntry;       // offset to the next available index entry
    DWORD       dwIndexEnd;         // one byte past the end of the index block
    DWORD       dwFlags;
} INDEX_INFO, *PINDEX_INFO;

//
// Flags for use in DB structure DB.dwFlags
//

#define DB_IN_MEMORY           0x00000001
#define DB_GUID_VALID          0x00000002


typedef struct _DB {
    // used for both read and write

    HANDLE      hFile;
    PVOID       pBase;              // for  both memory-mapping & buffered writes
    BOOL        bWrite;             // was it opened with create?
    DWORD       dwSize;             // the size of the whole db, in bytes

    DWORD       dwFlags;            // flags (such as IN-memory flag)

    GUID        guidDB;             // optional id for the database

    DWORD       dwIndexes;          // the number of indexes
    INDEX_INFO  aIndexes[MAX_INDEXES];  // data for the indexes

    // stuff that's used for read
    HANDLE      hSection;           // for memory-mapping
    TAGID       tiStringTable;      // pointer to the stringtable for string handling
    BOOL        bIndexesScanned;    // have the indexes been looked at?

    // stuff that's used for write
    struct _DB* pdbStringTable;    // stringtable is a subdatabase that's created on the side
    PVOID       pStringHash;        // stringtable hash (same info as in stringtable)
    DWORD       dwAllocatedSize;    // the size allocated for buffered writes
    BOOL        bWritingIndexes;    // are we in the process of allocating index space?
    TAGID       tiIndexes;          // used during index allocation

    //
    // BUGBUG Hack alert read from unaligned (v1.0) database is enabled here
    //
    BOOL        bUnalignedRead;


#ifdef WIN32A_MODE
    PVOID       pHashStringBody;    // hash of the strings located within the body
    PVOID       pHashStringTable;   // hash for the strings in the stringtable
#endif

#ifndef WIN32A_MODE
    UNICODE_STRING ustrTempStringtable; // string table temp filename
#else
    LPCTSTR        pszTempStringtable;
#endif


} DB, *PDB;


//
// We're using the high 4 bits of the TAGID to
// say what PDB the TAGID is from. Kludge? Perhaps.
//
#define PDB_MAIN            0x00000000
#define PDB_TEST            0x10000000

// all other entries are local (custom) pdbs

#define PDB_LOCAL           0x20000000

#define TAGREF_STRIP_TAGID  0x0FFFFFFF
#define TAGREF_STRIP_PDB    0xF0000000

typedef WCHAR* PWSZ;



ULONG
ShimExceptionHandler(
    PEXCEPTION_POINTERS pexi,
    char*               pszFile,
    DWORD               dwLine
    );

#if DBG
#define SHIM_EXCEPT_HANDLER ShimExceptionHandler(GetExceptionInformation(), __FILE__, __LINE__)
#else
#define SHIM_EXCEPT_HANDLER ShimExceptionHandler(GetExceptionInformation(), "", 0)
#endif


//
// Function prototypes for use in attributes.c (from version.dll)
//
//

typedef DWORD (WINAPI* PFNGetFileVersionInfoSize) (LPTSTR  lptstrFilename,
                                                   LPDWORD lpdwHandle);

typedef BOOL (WINAPI* PFNGetFileVersionInfo)(LPTSTR lpstrFilename,
                                             DWORD  dwHandle,
                                             DWORD  dwLen,
                                             LPVOID lpData);

typedef BOOL  (WINAPI* PFNVerQueryValue)(const LPVOID pBlock,
                                         LPTSTR       lpSubBlock,
                                         LPVOID*      lplpBuffer,
                                         PUINT        puLen);

#ifdef WIN32A_MODE

#define VERQUERYVALUEAPINAME          "VerQueryValueA"
#define GETFILEVERSIONINFOAPINAME     "GetFileVersionInfoA"
#define GETFILEVERSIONINFOSIZEAPINAME "GetFileVersionInfoSizeA"

#else

#define VERQUERYVALUEAPINAME          "VerQueryValueW"
#define GETFILEVERSIONINFOAPINAME     "GetFileVersionInfoW"
#define GETFILEVERSIONINFOSIZEAPINAME "GetFileVersionInfoSizeW"

#endif


//
// custom db cache entry and header
//
typedef struct tagUSERSDBLOOKUPENTRY {
    ULARGE_INTEGER liTimeStamp; // we don't need this item, but just for debugging ...
    GUID           guidDB;
} USERSDBLOOKUPENTRY, *PUSERSDBLOOKUPENTRY;

//
// Lookup vectors
//
//
typedef struct tagUSERSDBLOOKUP {

    struct tagUSERSDBLOOKUP* pNext;

    struct tagUSERSDBLOOKUP* pPrev;
    LPWSTR              pwszItemName;   // item name
    BOOL                bLayer;         // true if layer

    DWORD               dwCount;        // item count

    USERSDBLOOKUPENTRY  rgEntries[1];   // actual names

} USERSDBLOOKUP, *PUSERSDBLOOKUP;


//
// HSDB flags
//
#define HSDBF_USE_ATTRIBUTES    0x00000001

#define MAX_SDBS 16

/*++
    Flags for use with SdbOpenLocalDatabaseEx

--*/

#define SDBCUSTOM_GUID        0x00000001   // this is a "type" -- when specified, database guid is used to find/open the database
#define SDBCUSTOM_GUID_BINARY 0x00000001   // guid is provided in binary form
#define SDBCUSTOM_GUID_STRING 0x00010001   // guid is provided as a string "{....}"

#define SDBCUSTOM_PATH        0x00000002   // when specified, database path is used to find/open the database
#define SDBCUSTOM_PATH_DOS    0x00000002   // path is provided in dos form
#define SDBCUSTOM_PATH_NT     0x00010002   // path is provided in nt form

#define SDBCUSTOM_USE_INDEX   0x10000000   // when specified, an index is provided to use a particular entry within the sdb table

#define SDBCUSTOM_FLAGS(dwFlags)  ((dwFlags) & 0xFFFF0000) 
#define SDBCUSTOM_TYPE(dwFlags)   ((dwFlags) & 0x0FFFF)

#define SDBCUSTOM_SET_MASK(hSDB, dwIndex) \
    (((PSDBCONTEXT)hSDB)->dwDatabaseMask |= (1 << (dwIndex)))

#define SDBCUSTOM_CLEAR_MASK(hSDB, dwIndex) \
    (((PSDBCONTEXT)hSDB)->dwDatabaseMask &= ~(1 << (dwIndex)))
    
#define SDBCUSTOM_CHECK_INDEX(hSDB, dwIndex) \
    (((PSDBCONTEXT)hSDB)->dwDatabaseMask & (1 << (dwIndex)))

#define SDB_CUSTOM_MASK       0x0FFF8       // except 0, 1 and 2 -- bits for main, test and local

/*++
    These macros convert from the mask form (as found in TAGREF's high 4 bits) to
    index form and back
    
--*/

#define SDB_MASK_TO_INDEX(dwMask)  ((((DWORD)(dwMask)) >> 28) & 0x0F)
#define SDB_INDEX_TO_MASK(dwIndex) (((DWORD)(dwIndex)) << 28)


typedef struct tagSDBENTRY {
    GUID    guidDB;   // guid of a custom db 
    PDB     pdb;      // pdb for the db
    DWORD   dwFlags;  // see SDBENTRY_ flags
} SDBENTRY, *PSDBENTRY;


/*++
    Given a context and index (or mask) for an sdb - retrieve a pointer to 
    the appropriate entry (PSDBENTRY)

--*/
#define SDBGETENTRY(hSDB, dwIndex) \
        (&((PSDBCONTEXT)hSDB)->rgSDB[dwIndex])
#define SDBGETENTRYBYMASK(hSDB, dwMask) \
        SDBGETENTRY(hSDB, SDB_MASK_TO_INDEX(dwMask))

/*++
    Retrieve main, test and temporary entries respectively
--*/
#define SDBGETMAINENTRY(hSDB)  SDBGETENTRY(hSDB, SDB_MASK_TO_INDEX(PDB_MAIN))
#define SDBGETTESTENTRY(hSDB)  SDBGETENTRY(hSDB, SDB_MASK_TO_INDEX(PDB_TEST))
#define SDBGETLOCALENTRY(hSDB) SDBGETENTRY(hSDB, SDB_MASK_TO_INDEX(PDB_LOCAL))

#define SDB_LOCALDB_INDEX      SDB_MASK_TO_INDEX(PDB_LOCAL)
#define SDB_FIRST_ENTRY_INDEX  3   // since 0 is main, 1 is test and 2 is local


/*++
    Flags that are valid in SDBENTRY.dwFlags

--*/
#define SDBENTRY_VALID_GUID   0x00000001 // indicated that an entry has valid guid for lookup
#define SDBENTRY_VALID_ENTRY  0x00000002 // indicates whether an entry is free

#define SDBENTRY_INVALID_INDEX ((DWORD)-1)

/*++
    Macros that allow us access to some of the members of hSDB w/o derefencing the type
    Makes it a bit easier of the typecasts in code

--*/
#ifdef WIN32A_MODE

#define SDBCONTEXT_IS_INSTRUMENTED(hSDB) FALSE
#define SDBCONTEXT_GET_PIPE(hSDB)        INVALID_HANDLE_VALUE

#else 

#define SDBCONTEXT_GET_PIPE(hSDB) \
        (((PSDBCONTEXT)(hSDB))->hPipe)

#define SDBCONTEXT_IS_INSTRUMENTED(hSDB) \
        (((PSDBCONTEXT)(hSDB))->hPipe != INVALID_HANDLE_VALUE)

#endif


typedef struct tagSDBCONTEXT {

    DWORD dwFlags;

    //
    // Database handles
    //

    PDB pdbMain;  // main database (sysmain)
    PDB pdbTest;  // test database (systest)
    PDB pdbLocal; // local database

    // 
    // database table
    // 
    DWORD dwDatabaseCount; // number of entries in the table below
    DWORD dwDatabaseMask;  // bit-field mask for databases
    SDBENTRY rgSDB[MAX_SDBS]; 

    //
    // Pointer to the file attribute cache (see attributes.c for details)
    //

    PVOID pFileAttributeCache;

    //
    // function pointers for use with version.dll
    // (see attributes.c)
    //
    PFNVerQueryValue            pfnVerQueryValue;
    PFNGetFileVersionInfo       pfnGetFileVersionInfo;
    PFNGetFileVersionInfoSize   pfnGetFileVersionInfoSize;

    //
    // processor architecture, cached to perform checks of RUNTIME_PLATFORM
    //
    DWORD dwRuntimePlatform;

    //
    // OS SKU
    //
    DWORD dwOSSKU;

    //
    // OS SP mask
    //
    DWORD dwSPMask;

    //
    // User SDB cache
    //
    PUSERSDBLOOKUP pLookupHead;

#ifndef WIN32A_MODE 
    //
    // debug pipe
    //
    HANDLE hPipe;

#endif // WIN32A_MODE

} SDBCONTEXT, *PSDBCONTEXT;


//
// These flags are used to direct
// SearchDB routine not to use process_history or
// to prepare for lookup in local DB
//

#define SEARCHDBF_INITIALIZED          0x00000001
#define SEARCHDBF_NO_PROCESS_HISTORY   0x00000002
//
// note the gap here -- there was a flag related to local dbs - it's 
// defunct and has been removed
//
#define SEARCHDBF_NO_ATTRIBUTE_CACHE   0x00000008
#define SEARCHDBF_NO_LFN               0x00000010

typedef struct tagSEARCHPATHPART {
    LPCTSTR  pszPart;
    ULONG    PartLength;
} SEARCHPATHPART, *PSEARCHPATHPART;

typedef struct tagSEARCHPATH {
    ULONG PartCount; // count parts
    SEARCHPATHPART Parts[];
} SEARCHPATHPARTS, *PSEARCHPATHPARTS;


typedef struct tagSEARCHDBCONTEXT {

    DWORD   dwFlags;      // flags directing how the context is used
                          // we may, for instance, not want to use ProcessHistory
                          // at all SEARCHDBF* flags apply

    HANDLE  hMainFile;    // handle of the main file we are checking
    LPVOID  pImageBase;   // pointer to image base for the main file. We will use the image pointer
    DWORD   dwImageSize;  // image size as provided by k-mode code

    LPTSTR  szDir;        // directory, we allocate it, we free it
    LPTSTR  szName;       // filename for the file we're looking up, we allocate and free it
    LPTSTR  szModuleName; // for 16-bit apps only; we allocate and free

    LPCTSTR pEnvironment; // we DON'T touch this at all
    LPTSTR  szProcessHistory; // buffer for the search path string (unparsed), allocated by us, we free it

    PSEARCHPATHPARTS pSearchParts; // search path undone, we allocate and free it

} SEARCHDBCONTEXT, *PSEARCHDBCONTEXT;

// HASH structures

typedef struct tagStringHashElement {
    TCHAR*                          szStr;  // the string itself (points past buffer)
    STRINGREF                       srStr;  // stringref (where the string is)
    struct tagStringHashElement*    pNext;

} STRHASHELEMENT, *PSTRHASHELEMENT;


typedef struct tagStringHash {
    DWORD            dwHashSize; // hash size
    PSTRHASHELEMENT* pTable;

} STRHASH, *PSTRHASH;


#ifndef WIN32A_MODE

//
// apphelp info stuff (see apphelp.c)
//

//
// dwContextFlags can have these values:
//
#define AHC_DBDETAILS_NOCLOSE 0x00000001
#define AHC_HSDB_NOCLOSE      0x00000002

typedef struct tagAPPHELPINFOCONTEXT {
    HSDB    hSDB; // handle to the database

    PDB     pdb;           // pdb where we have exe or null (we work through hsdb then
    PDB     pdbDetails;    // pdb where we have details
    DWORD   dwDatabaseType; // this is the database type (of the db that contains the match)
    DWORD   dwContextFlags; // flags specific to the context

    GUID    guidDB;        // database guid
    GUID    guidID;        // guid of the matching entry

    DWORD   dwMask;       // mask which tells us whether members are valid

    TAGID   tiExe;        // tagid of an exe entry
    TAGID   tiApphelpExe; // apphelp in the main db
    DWORD   dwHtmlHelpID; // html help id
    DWORD   dwSeverity;
    DWORD   dwFlags;


    TAGID   tiApphelpDetails;    // apphelp stuff in the details db
    TAGID   tiLink;
    LPCWSTR pwszAppName;
    LPCWSTR pwszApphelpURL;
    LPCWSTR pwszVendorName;
    LPCWSTR pwszExeName;
    LPCWSTR pwszLinkURL;
    LPCWSTR pwszLinkText;
    LPCWSTR pwszTitle;
    LPCWSTR pwszDetails;
    LPCWSTR pwszContact;

    LPWSTR  pwszHelpCtrURL;     // help center URL

    BOOL    bOfflineContent;    // pass FALSE
    BOOL    bUseHtmlHelp;       // pass FALSE
    UNICODE_STRING ustrChmFile;
    UNICODE_STRING ustrDetailsDatabase;

} APPHELPINFOCONTEXT, *PAPPHELPINFOCONTEXT;

#endif // WIN32A_MODE

void* SdbAlloc(size_t size);
void  SdbFree(void* pWhat);


// Base primitives.

HANDLE
SdbpOpenFile(
    LPCTSTR   szPath,
    PATH_TYPE eType
    );

#if defined(WIN32A_MODE) || defined(WIN32U_MODE)
    #define SdbpCloseFile(hFile) CloseHandle(hFile)
#else
    #define SdbpCloseFile(hFile) NtClose(hFile)
#endif

BOOL
SdbpCreateSearchPathPartsFromPath(
    IN  LPCTSTR           pszPath,
    OUT PSEARCHPATHPARTS* ppSearchPathParts
    );

BOOL
SdbpGetLongFileName(
    IN  LPCTSTR szFullPath,
    OUT LPTSTR  szLongFileName
    );

void
SdbpGetWinDir(
    LPTSTR pwszDir
    );

void
SdbpGetAppPatchDir(
    LPTSTR szAppPatchPath
    );

DWORD
SdbExpandEnvironmentStrings(
    IN  LPCTSTR lpSrc,
    OUT LPTSTR  lpDst,
    IN  DWORD   nSize);

BOOL
SdbpGUIDFromString(
    LPCTSTR lpszGuid,
    GUID* pGuid
    );


DWORD
SdbpGetStringRefLength(
    HSDB   hSDB,
    TAGREF trString
    );

LPCTSTR
SdbpGetStringRefPtr(
    IN HSDB hSDB,
    IN TAGREF trString
    );

BOOL
SdbpWriteBitsToFile(
    LPCTSTR szFile,
    PBYTE   pBuffer,
    DWORD   dwSize
    );

// DB access primitives

void
SdbCloseDatabaseRead(
    PDB pdb
    );

BOOL
SdbpOpenAndMapDB(
    PDB       pdb,
    LPCTSTR   pszPath,
    PATH_TYPE eType
    );

PDB
SdbpOpenDatabaseInMemory(
    LPVOID pImageDatabase,
    DWORD  dwSize
    );

BOOL
SdbpUnmapAndCloseDB(
    PDB pdb
    );

DWORD
SdbpGetFileSize(
    HANDLE hFile
    );

BOOL
SdbpReadMappedData(
    PDB   pdb,
    DWORD dwOffset,
    PVOID pBuffer,
    DWORD dwSize
    );

PVOID
SdbpGetMappedData(
    PDB   pdb,
    DWORD dwOffset
    );

TAGID
SdbpGetNextTagId(
    PDB   pdb,
    TAGID tiWhich
    );

DWORD
SdbpGetStandardDatabasePath(
    IN  DWORD  dwDatabaseType,
    IN  DWORD  dwFlags,                      // specify HID_DOS_PATHS for dos paths
    OUT LPTSTR pszDatabasePath,
    IN  DWORD  dwBufferSize    // in tchars
    );

LPTSTR
GetProcessHistory(
    IN  LPCTSTR pEnvironment,
    IN  LPTSTR  szDir,
    IN  LPTSTR  szName
    );


void
PrepareFormatForUnicode(
    PCH fmtUnicode,
    PCH format
    );

#ifndef WIN32A_MODE

#define PREPARE_FORMAT(pszFormat, Format) \
    {                                                                           \
        STACK_ALLOC(pszFormat, (strlen(Format) + 1) * sizeof(*Format));         \
        if (pszFormat != NULL) {                                                \
            PrepareFormatForUnicode(pszFormat, Format);                         \
        }                                                                       \
    }


#define CONVERT_FORMAT(pwsz, psz) \
    {                                                                           \
        ANSI_STRING    str;                                                     \
        UNICODE_STRING ustr;                                                    \
        ULONG          Length;                                                  \
        NTSTATUS       Status;                                                  \
                                                                                \
        RtlInitAnsiString(&str, (psz));                                         \
        Length = RtlAnsiStringToUnicodeSize(&str);                              \
        pwsz = (LPWSTR)_alloca(Length);                                         \
                                                                                \
        if (pwsz != NULL) {                                                     \
            ustr.MaximumLength = (USHORT)Length;                                \
            ustr.Buffer        = pwsz;                                          \
            Status = RtlAnsiStringToUnicodeString(&ustr, &str, FALSE);          \
            if (!NT_SUCCESS(Status)) {                                          \
                pwsz = NULL;                                                    \
            }                                                                   \
        }                                                                       \
    }

#else // WIN32A_MODE

#define PREPARE_FORMAT(pszFormat, Format) (pszFormat = (Format))

#define CONVERT_FORMAT(pwsz, psz) (pwsz = (psz))

#endif // WIN32A_MODE

#ifdef KERNEL_MODE

    #define SdbpGetWow64Flag() KEY_WOW64_64KEY

#else // !KERNEL_MODE

    DWORD SdbpGetWow64Flag(VOID);

#endif // KERNEL_MODE

// READ

DWORD
SdbpGetTagHeadSize(
    PDB   pdb,
    TAGID tiWhich
    );

TAGID
SdbpGetLibraryFile(
    IN  PDB     pdb,           // handle to the database channel
    IN  LPCTSTR szDllName       // the name of the FILE to find in LIBRARY (main db only)
    );

#define SdbpGetMainLibraryFile(hSDB, szFileName) \
    SdbpGetLibraryFile(((PSDBCONTEXT)(hSDB))->pdbMain, (szFileName))

STRINGREF SdbpReadStringRef(PDB pdb, TAGID tiWhich);

BOOL SdbpReadStringFromTable(PDB pdb, STRINGREF srData, LPTSTR szBuffer, DWORD dwBufferSize);

//
// Custom db stuff
//

VOID
SdbpCleanupUserSDBCache(
    IN PSDBCONTEXT pSdbContext
    );

HANDLE
SdbpCreateKeyPath(
    LPCWSTR pwszPath,
    BOOL    bMachine
    );


BOOL
SdbOpenNthLocalDatabase(
    IN  HSDB    hSDB,           // handle to the database channel
    IN  LPCTSTR pszItemName,    // the name of the exectutable, without the path or the layer name
    IN  LPDWORD pdwIndex,       // zero based index of the local DB to open
    IN  BOOL    bLayer
    );


BOOL
SdbpAddMatch(                   // internal function see sdbapi for more info
    IN OUT PSDBQUERYRESULT pQueryResult,
    IN PSDBCONTEXT         pSdbContext,
    IN PDB                 pdb,
    IN TAGID*              ptiExes,
    IN DWORD               dwNumExes,
    IN TAGID*              ptiLayers,
    IN DWORD               dwNumLayers,
    IN GUID*               pguidExeID,
    IN DWORD               dwExeFlags,
    IN OUT PMATCHMODE      pMode
);


BOOL
SdbOpenLocalDatabaseEx(
    IN  HSDB       hSDB,
    IN  LPCVOID    pDatabaseID,
    IN  DWORD      dwFLags,
    OUT PDB*  pPDB OPTIONAL,
    IN OUT LPDWORD pdwLocalDBMask OPTIONAL // local db mask for tagref
    );


BOOL
SdbCloseLocalDatabaseEx(
    IN HSDB hSDB,
    IN PDB  pdb,
    IN DWORD dwIndex
    );



BOOL 
SdbpIsMainPDB(
    IN HSDB hSDB,
    IN PDB  pdb
    );

BOOL
SdbpIsLocalTempPDB(
    IN HSDB hSDB,
    IN PDB  pdb
    );

DWORD
SdbpRetainLocalDBEntry(
    IN  HSDB hSDB,
    OUT PDB* ppPDB OPTIONAL // optional pointer to the pdb
    );

BOOL
SdbpCleanupLocalDatabaseSupport(
    IN HSDB hSDB
    );

BOOL
SdbpFindLocalDatabaseByGUID(
    IN HSDB     hSDB,
    IN GUID*    pGuidDB,
    IN BOOL     bExcludeLocalDB,
    OUT LPDWORD pdwIndex 
    );

BOOL
SdbpFindLocalDatabaseByPDB(
    IN  HSDB    hSDB,
    IN  PDB     pdb,
    IN  BOOL    bExcludeLocalDB, // exclude local temp db entry?
    OUT LPDWORD pdwIndex
    );

LPCTSTR
SdbpGetDatabaseDescriptionPtr(
    IN PDB pdb
    );

// HASH

PVOID
HashCreate(
    void
    );


void
HashFree(
    PVOID pStringHash
    );

DWORD
HashString(
    PSTRHASH pHash,
    LPCTSTR  szString
    );


DWORD
HashStringRef(
    PSTRHASH pHash,
    STRINGREF srString);

// BULK

BOOL
SdbpReadMappedData(
    PDB   pdb,
    DWORD dwOffset,
    PVOID pBuffer,
    DWORD dwSize
    );

BOOL
SdbpCheckForMatch(
    HSDB             pDBContext,
    PDB              pdb,
    TAGID            tiExe,
    PSEARCHDBCONTEXT pContext,
    PMATCHMODE       pMMode,
    GUID*            pGUID,
    DWORD*           pdwFlags
    );

BOOL
bGetExeID(
    PDB   pdb,
    TAGID tiExe,
    GUID* pGuid
    );

BOOL
SdbpBinarySearchUnique(
    PINDEX_RECORD pRecords,
    DWORD         nRecords,
    ULONGLONG     ullKey,
    DWORD*        pdwIndex
    );

BOOL
SdbpBinarySearchFirst(
    PINDEX_RECORD pRecords,
    DWORD         nRecords,
    ULONGLONG     ullKey,
    DWORD*        pdwIndex
    );

char*
SdbpKeyToAnsiString(
    ULONGLONG ullKey,
    char*     szString
    );

// ATTRIBUTES

BOOL
SafeNCat(
    LPTSTR  lpszDest,
    int     nSize,
    LPCTSTR lpszSrc,
    int     nSizeAppend
    );

BOOL
SdbpSanitizeXML(
    LPTSTR  pchOut,
    int     nSize,
    LPCTSTR lpszXML
    );


////////////////////////////////////////////////////////////////////////////
//
//  Image File Data
//  Helpful structure that is used in functions dealing with
//  image properties retrieval
//

typedef struct tagIMAGEFILEDATA {
    HANDLE    hFile;        // we do not manage this

    DWORD     dwFlags;      // flags that tell us not to mess with the file's handle

    HANDLE    hSection;     // section of the fileview
    PVOID     pBase;        // base ptr
    SIZE_T    ViewSize;     // size of the view
    ULONGLONG FileSize;     // size of the file

} IMAGEFILEDATA, *PIMAGEFILEDATA;

#define IMAGEFILEDATA_HANDLEVALID 0x00000001
#define IMAGEFILEDATA_NOFILECLOSE 0x00000002
#define IMAGEFILEDATA_PBASEVALID  0x00000004
#define IMAGEFILEDATA_NOFILEMAP   0x00000008

//
// FILEINFORMATION structure used in file attribute cache, see attributes.c
//
//

typedef struct tagFILEINFORMATION {

    //
    // "Signature" to insure that it's legitimate memory when
    // operating of file attributes
    //
    DWORD  dwMagic;

    HANDLE hFile;  // we store this handle
    LPVOID pImageBase;
    DWORD  dwImageSize;

    //
    // pointer to the next item in cache
    //

    struct tagFILEINFORMATION* pNext; // pointer to the next item in cache

    LPTSTR  FilePath;        // file name with path (allocated by us with this struct)
    DWORD   dwFlags;         // flags

    PVOID   pVersionInfo;    // version info ptr, retained (allocated by us)
    LPTSTR  pDescription16;  // string, points to the buffer for 16-bit description
    LPTSTR  pModuleName16;   // string, points to the buffer for 16-bit module name

    ATTRINFO Attributes[];

} FILEINFO, *PFILEINFO;


//
// This structure is used to recover directory-related attributes of a file
// we used to have time here as well... but not anymore
// only low part of the file size is of any significance
//

typedef struct tagFILEDIRECTORYATTRIBUTES {

    DWORD  dwFlags; // flags that show which attributes are valid

    DWORD  dwFileSizeHigh;
    DWORD  dwFileSizeLow;

} FILEDIRECTORYATTRIBUTES, *PFILEDIRECTORYATTRIBUTES;


//
// Attribute names. Use SdbTagToString if you want to get the name of
// a tag ID.
//
typedef struct _TAG_INFO {
    TAG         tWhich;
    TCHAR*      szName;
} TAG_INFO, *PTAG_INFO;

typedef struct _MOD_TYPE_STRINGS {
    DWORD      dwModuleType;
    LPTSTR     szModuleType;
}   MOD_TYPE_STRINGS;

typedef struct tagLANGANDCODEPAGE {
    WORD wLanguage;
    WORD wCodePage;
} LANGANDCODEPAGE, *PLANGANDCODEPAGE;


BOOL
SdbpGetHeaderAttributes(
    IN  PSDBCONTEXT pContext,
    OUT PFILEINFO   pFileInfo
    );

LPTSTR
SdbpQueryVersionString(
    HSDB             hSDB,
    PVOID            pVersionData,
    PLANGANDCODEPAGE pTranslations,
    DWORD            dwCount,
    LPCTSTR          szString
    );

BOOL
SdbpGetFileChecksum(
    PULONG         pChecksum,
    PIMAGEFILEDATA pImageData
    );

BOOL
SdbpGetModulePECheckSum(
    PULONG         pChecksum,
    LPDWORD        pdwLinkerVersion,
    LPDWORD        pdwLinkDate,
    PIMAGEFILEDATA pImageData
    );

BOOL
SdbpCheckVersion(
    ULONGLONG qwDBFileVer,
    ULONGLONG qwBinFileVer
    );

BOOL
SdbpCheckUptoVersion(
    ULONGLONG qwDBFileVer,
    ULONGLONG qwBinFileVer
    );


#ifdef KERNEL_MODE

//
// Special versions of functions for kernel-mode implementation (in ntkmode.c).
//
BOOL
SdbpGetFileDirectoryAttributesNT(
    PFILEINFO      pFileInfo,
    PIMAGEFILEDATA pImageData
    );

BOOL
SdbpQueryFileDirectoryAttributesNT(
    PIMAGEFILEDATA           pImageData,
    PFILEDIRECTORYATTRIBUTES pFileDirectoryAttributes
    );

#else

BOOL
SdbpGetFileDirectoryAttributes(
    OUT PFILEINFO pFileInfo
    );

BOOL
SdbpGetVersionAttributes(
    IN  PSDBCONTEXT pContext,
    OUT PFILEINFO   pFileInfo
    );

#endif // KERNEL_MODE


int
TagToIndex(
    IN  TAG tag                 // the tag
    );

BOOL
SdbpSetAttribute(
    OUT PFILEINFO pFileInfo,    // pointer to the FILEINFO structure.
    IN  TAG       AttrID,       // Attribute ID (tag, as in TAG_SIZE
    IN  PVOID     pValue        // value
    );

void
SdbpQueryStringVersionInformation(
    IN  PSDBCONTEXT pContext,
    IN  PFILEINFO   pFileInfo,
    OUT LPVOID      pVersionInfo
    );

VOID
SdbpQueryBinVersionInformation(
    IN  PSDBCONTEXT       pContext,
    IN  PFILEINFO         pFileInfo,
    OUT VS_FIXEDFILEINFO* pFixedInfo
    );

BOOL
SdbpGetAttribute(
    IN  PSDBCONTEXT pContext,
    OUT PFILEINFO   pFileInfo,
    IN  TAG         AttrID
    );

BOOL
SdbpGetImageNTHeader(
    OUT PIMAGE_NT_HEADERS* ppHeader,
    IN  PIMAGEFILEDATA     pImageData
    );

BOOL
SdbpGetVersionAttributesNT(
    PSDBCONTEXT    pContext,
    PFILEINFO      pFileInfo,
    PIMAGEFILEDATA pImageData
    );

VOID
SdbpCleanupAttributeMgr(
    PSDBCONTEXT pContext
    );

BOOL
SdbpCheckAttribute(
    HSDB  hSDB,
    PVOID pFileData,
    TAG   tAttrID,
    PVOID pAttribute
    );

BOOL
SdbpCheckAllAttributes(
    HSDB hSDB,
    PDB pdb,
    TAGID tiMatch,
    PVOID pFileData);



// READ FUNCTIONS

BOOL SdbpReadTagData(PDB pdb, TAGID tiWhich, PVOID pBuffer, DWORD dwBufferSize);

// WRITE

BOOL
SdbpWriteTagData(
    PDB         pdb,
    TAG         tTag,
    const PVOID pBuffer,
    DWORD       dwSize
    );


// STRING FUNCTIONS

WCHAR* SdbpGetMappedStringFromTable(PDB pdb, STRINGREF srData);

STRINGREF SdbpAddStringToTable(PDB pdb, LPCTSTR szData);

// INDEX FUNCTIONS

PINDEX_RECORD
SdbpGetIndex(
    PDB    pdb,
    TAGID  tiIndex,
    DWORD* pdwNumRecs
    );

void
SdbpScanIndexes(
    PDB pdb
    );

TAGID
SdbpGetFirstIndexedRecord(
    PDB        pdb,
    TAGID      tiIndex,
    ULONGLONG  ullKey,
    FIND_INFO* pFindInfo
    );

TAGID
SdbpGetNextIndexedRecord(
    PDB        pdb,
    TAGID      tiIndex,
    FIND_INFO* pFindInfo
    );

TAGID
SdbpFindFirstIndexedWildCardTag(
    PDB          pdb,
    TAG          tWhich,
    TAG          tKey,
    LPCTSTR      szName,
    FIND_INFO*   pFindInfo
    );

TAGID
SdbpFindNextIndexedWildCardTag(
    PDB        pdb,
    FIND_INFO* pFindInfo
    );

BOOL
SdbpSortIndex(
    PDB   pdb,
    TAGID tiIndexBits
    );

ULONGLONG
SdbpTagToKey(
    PDB   pdb,
    TAGID tiTag
    );


// FINDTAG

TAGID
tiFindFirstNamedTag(
    PDB          pdb,
    TAGID        tiParent,
    TAG          tToFind,
    TAG          tName,
    LPCTSTR      pszName
    );

TAGID
SdbpFindNextNamedTag(
    PDB          pdb,
    TAGID        tiParent,
    TAGID        tiPrev,
    TAG          tName,
    LPCTSTR      pszName
    );

TAGID
SdbpFindMatchingName(
    PDB        pdb,
    TAGID      tiStart,
    FIND_INFO* pFindInfo
    );

TAGID
SdbpFindMatchingDWORD(
    PDB        pdb,
    TAGID      tiStart,
    FIND_INFO* pFindInfo
    );

TAGID
SdbpFindMatchingGUID(
    IN  PDB        pdb,         // DB to use
    IN  TAGID      tiStart,     // the tag where to start from
    IN  FIND_INFO* pFindInfo    // pointer to the search context structure
    );

BOOL bTagRefToTagID(HSDB, TAGREF trWhich, PDB* ppdb, TAGID* ptiWhich);

DWORD SdbpGetTagRefDataSize(HSDB, TAGREF trWhich);

BOOL SdbpReadBinaryTagRef(HSDB, TAGREF trWhich, PBYTE pBuffer, DWORD dwBufferSize);


//
// Debug functions (pipe-related)
//
HANDLE
SdbpOpenDebugPipe(
    VOID
    );

BOOL
SdbpCloseDebugPipe(
    IN HANDLE hPipe
    );

BOOL
SdbpWriteDebugPipe(
    HSDB    hSDB,
    LPCSTR  pszBuffer
    );


//
// APPCOMPAT_EXE_DATA
//
//

#define MAX_SHIM_ENGINE_NAME    32

typedef struct tagAPPCOMPAT_EXE_DATA {
    //
    // WARNING: never ever change the position of 'szShimEngine'.
    //
    // It MUST be the first element of this structure
    //
    // this structure is referenced during installation of
    // an appcompat backend (base\ntdll)

    WCHAR       szShimEngine[MAX_SHIM_ENGINE_NAME];

    DWORD       dwFlags;        // flags (if any)
    DWORD       cbSize;         // struct size(allocation size)
    DWORD       dwMagic;        // magic (signature)

    TAGREF      atrExes[SDB_MAX_EXES];
    TAGREF      atrLayers[SDB_MAX_LAYERS];
    TAGREF      trAppHelp;      // if there's an apphelp to display

    DWORD       dwDatabaseMap;    // count local dbs
    GUID        rgGuidDB[MAX_SDBS]; // local dbs

} APPCOMPAT_EXE_DATA, *PAPPCOMPAT_EXE_DATA;



PVOID SdbpGetMappedTagData(PDB pdb, TAGID tiWhich);
BOOL  bWStrEqual(const WCHAR* szOne, const WCHAR* szTwo);
BOOL bFlushBufferedData(PDB pdb);
void vReleaseBufferedData(PDB pdb);



BOOL SdbpPatternMatchAnsi(LPCSTR pszPattern, LPCSTR pszTestString);
BOOL SdbpPatternMatch(LPCTSTR pszPattern, LPCTSTR pszTestString);

//
// Registry access functions
//
//

typedef WCHAR* PWSZ;

void
SdbpQueryAppCompatFlagsByExeID(
    LPCWSTR         pwszKeyPath,
    PUNICODE_STRING pustrExeID,
    LPDWORD         lpdwFlags
    );

#ifdef _DEBUG_SPEW

typedef struct tagDBGLEVELINFO {
    
    LPCSTR  szStrTag;
    INT     iLevel;

} DBGLEVELINFO;

#define DEBUG_LEVELS    4

//
// Shim Debug Level variable
// In it's initial state -- we have -1 here,
// further, upon the very first call to ShimDbgPrint, we examine the
// environment variable -- and then we set it up appropriately
//
#define SHIM_DEBUG_UNINITIALIZED 0x0C0FFEE


#endif // _DEBUG_SPEW


/*++

    bWStrEqual

    Currently a wrapper for _wcsicmp. Potentially will use a faster
    routine that just checks equality, rather than also trying to get
    less than/greater than.

--*/
#define bWStrEqual(s1, s2) (0 == _wcsicmp((s1), (s2)))

#define ISEQUALSTRING(s1, s2) (0 == _tcsicmp((s1), (s2)))


/*++

    dwGetTagDataOffset

    Returns the total size of the tag: the tag header plus the tag data.
    Used for skipping past a tag and going to the next tag in the file.

--*/


//
// HACK ALERT BUGBUG
// remove this when the code to write aligned db has propagated
// throught
//

#define GETTAGDATASIZEALIGNED(pdb, tiWhich) \
    ((pdb)->bUnalignedRead ? (SdbGetTagDataSize(pdb, tiWhich)) : \
                             ((SdbGetTagDataSize(pdb, tiWhich) + 1) & (~1)))

#if 0 // this is good code that we should but back at some point

#define GETTAGDATASIZEALIGNED(pdb, tiWhich) \
    ((SdbGetTagDataSize(pdb, tiWhich) + 1) & (~1))

#endif // End good code

#define GETTAGDATAOFFSET(pdb, tiWhich) \
    (GETTAGDATASIZEALIGNED(pdb, tiWhich) + SdbpGetTagHeadSize(pdb, tiWhich))



#ifndef WIN32A_MODE

///////////////////////////////////////////////////////////////////////////////////
//
//  UNICODE - specific macros and definitions
//

#define IS_MEMORY_EQUAL(p1, p2, Size) RtlEqualMemory(p1, p2, Size)

#define CONVERT_STRINGPTR(pdb, pwszSrc, tagType, srWhich) ((WCHAR*)pwszSrc)

#define READ_STRING(pdb, tiWhich, pwszBuffer, dwBufferSize) \
    (SdbpReadTagData((pdb), (tiWhich), (pwszBuffer), (dwBufferSize) * sizeof(WCHAR)))

//
// The macro below is a substitution for a function that exists in non-unicode code
//
#define SdbpDoesFileExists(FilePath) RtlDoesFileExists_U(FullPath)

NTSTATUS
SdbpGUIDToUnicodeString(
    IN  GUID* pGuid,
    OUT PUNICODE_STRING pUnicodeString
    );

VOID
SdbpFreeUnicodeString(
    PUNICODE_STRING pUnicodeString
    );

#define GUID_TO_UNICODE_STRING(pGuid, pUnicodeString) \
    SdbpGUIDToUnicodeString(pGuid, pUnicodeString)

#define FREE_GUID_STRING(pUnicodeString) \
    SdbpFreeUnicodeString(pUnicodeString)

#ifdef KERNEL_MODE

NTSTATUS
SdbpUpcaseUnicodeStringToMultiByteN(
    OUT LPSTR   lpszDest,  // dest buffer
    IN  DWORD   dwSize,    // size in characters
    IN  LPCWSTR lpszSrc    // source
    );

BOOL SdbpCreateUnicodeString(
    PUNICODE_STRING pStr,
    LPCWSTR         lpwsz
    );


BOOL
SdbpDoesFileExists_U(
    LPCWSTR pwszPath
    );


#define DOES_FILE_EXISTS_U(pwszPath) \
    SdbpDoesFileExists_U(pwszPath)

#define UPCASE_UNICODETOMULTIBYTEN(szDest, dwDestSize, szSrc) \
    SdbpUpcaseUnicodeStringToMultiByteN(szDest, dwDestSize, szSrc)




#else // not KERNEL_MODE code below

#define DOES_FILE_EXISTS_U(pwszPath) \
    RtlDoesFileExists_U(pwszPath)

#define UPCASE_UNICODETOMULTIBYTEN(szDest, dwDestSize, szSrc)       \
    RtlUpcaseUnicodeToMultiByteN((szDest),                          \
                                 (dwDestSize) * sizeof(*(szDest)),  \
                                 NULL,                              \
                                 (WCHAR*)(szSrc),                   \
                                 (wcslen((szSrc)) + 1) * sizeof(WCHAR))


#define FREE_TEMP_STRINGTABLE(pdb) \
    RtlFreeUnicodeString(&pdb->ustrTempStringtable)

#define COPY_TEMP_STRINGTABLE(pdb, pszTempStringtable) \
    RtlCreateUnicodeString(&pdb->ustrTempStringtable, pszTempStringtable)


void
SdbpGetCurrentTime(
    LPSYSTEMTIME lpTime
    );

BOOL
SdbpBuildUserKeyPath(
    IN  LPCWSTR         pwszPath,
    OUT PUNICODE_STRING puserKeyPath
    );


#endif // KERNEL_MODE

//
// Convert unicode char to upper case
//
#define UPCASE_CHAR(ch) RtlUpcaseUnicodeChar((ch))

//
// String cache which does not exist in unicode
//

#define CLEANUP_STRING_CACHE_READ(pdb)

#define SDB_BREAK_POINT() DbgBreakPoint()


#else // WIN32A_MODE

#define IS_MEMORY_EQUAL(p1, p2, Size) (memcmp((p1), (p2), (Size)) == 0)


//
// From Win32Base.c
//

LPSTR
SdbpFastUnicodeToAnsi(
    IN  PDB      pdb,
    IN  LPCWSTR  pwszSrc,
    IN  TAG_TYPE ttTag,
    IN  DWORD    dwRef
    );

BOOL
SdbpReadStringToAnsi(
    PDB    pdb,
    TAGID  tiWhich,
    LPSTR  pszBuffer,
    DWORD  dwBufferSize);

#define CONVERT_STRINGPTR(pdb, pwszSrc, tagType, srWhich) \
    SdbpFastUnicodeToAnsi(pdb, (WCHAR*)pwszSrc, tagType, (DWORD)srWhich)

#define READ_STRING(pdb, tiWhich, pwszBuffer, dwBufferSize) \
    (SdbpReadStringToAnsi((pdb), (tiWhich), (pwszBuffer), (dwBufferSize)))

BOOL
SdbpDoesFileExists(
    LPCTSTR pszFilePath
    );

#define UPCASE_CHAR(ch) _totupper((ch))

#define UPCASE_UNICODETOMULTIBYTEN(szDest, dwDestSize, szSrc) \
    (_tcsncpy((szDest), (szSrc), (dwDestSize)), \
     (szDest)[(dwDestSize) - 1] = 0,            \
     _tcsupr((szDest)),                         \
     STATUS_SUCCESS)

#define FREE_LOCALDB_NAME(pSDBContext) \
    {                                               \
        if (NULL != pSDBContext->pszPDBLocal) {     \
            SdbFree(pSDBContext->pszPDBLocal);      \
            pSDBContext->pszPDBLocal = NULL;        \
        }                                           \
    }

#define COPY_LOCALDB_NAME(pSDBContext, pszLocalDatabase) \
    ((pSDBContext->pszPDBLocal = SdbpDuplicateString(pszLocalDatabase)),   \
     (NULL != pSDBContext->pszPDBLocal))

#define CLEANUP_STRING_CACHE_READ(pdb) \
    {                                           \
        if (pdb->pHashStringTable != NULL) {    \
            HashFree(pdb->pHashStringTable);    \
            pdb->pHashStringTable = NULL;       \
        }                                       \
                                                \
        if (pdb->pHashStringBody != NULL) {     \
            HashFree(pdb->pHashStringBody);     \
            pdb->pHashStringBody = NULL;        \
        }                                       \
    }

#define FREE_TEMP_STRINGTABLE(pdb) \
    if (pdb->pszTempStringtable) { \
        SdbFree(pdb->pszTempStringtable); \
        pdb->pszTempStringtable = NULL;   \
    }

#define COPY_TEMP_STRINGTABLE(pdb, pszTempStringtable) \
    ((pdb->pszTempStringtable = SdbpDuplicateString(pszTempStringtable)), \
     (NULL != pdb->pszTempStringtable))

#define SDB_BREAK_POINT() DebugBreak()

#define GUID_TO_STRING SdbGUIDToString

#endif // WIN32A_MODE




BOOL
SdbpMapFile(
    HANDLE hFile,   // handle to the open file (this is done previously)
    PIMAGEFILEDATA pImageData
);

BOOL
SdbpUnmapFile(
    PIMAGEFILEDATA pImageData
);

BOOL
SdbpOpenAndMapFile(
    IN  LPCTSTR szPath,
    OUT PIMAGEFILEDATA pImageData,
    IN  PATH_TYPE ePathType
    );

BOOL
SdbpUnmapAndCloseFile(
    PIMAGEFILEDATA pImageData
    );

NTSTATUS
SdbpGetEnvVar(
    IN  LPCTSTR pEnvironment,
    IN  LPCTSTR pszVariableName,
    OUT LPTSTR  pszVariableValue,
    OUT LPDWORD pdwBufferSize);


LPTSTR HashAddStringByRef(PSTRHASH pHash, LPCTSTR szString, STRINGREF srString);
LPTSTR HashFindStringByRef(PSTRHASH pHash, STRINGREF srString);

/////////////////////////////////////////////////////////////////////////////////
//
// Private versions of functions to check for resources...
// found in ntver.c
//

BOOL
SdbpVerQueryValue(
    const LPVOID    pb,
    LPVOID          lpSubBlockX,    // can be only unicode
    LPVOID*         lplpBuffer,
    PUINT           puLen
    );

BOOL
SdbpGetFileVersionInformation(
    IN  PIMAGEFILEDATA     pImageData,        // we assume that the file has been mapped in for other purposes
    OUT LPVOID*            ppVersionInfo,     // receives pointer to the (allocated) version resource
    OUT VS_FIXEDFILEINFO** ppFixedVersionInfo // receives pointer to fixed version info
    );

BOOL
SdbpGetModuleType(                      // retrieve module type
    OUT LPDWORD lpdwModuleType,         // OUT - module type
    IN  PIMAGEFILEDATA pImageData       // IN  - image data
    );


BOOL
SdbpCreateSearchDBContext(
    PSEARCHDBCONTEXT pContext,
    LPCTSTR          szPath,
    LPCTSTR          szModuleName,
    LPCTSTR          pEnvironment
    );

DWORD
SdbpSearchDB(
    IN  HSDB             hSDB,
    IN  PDB              pdb,           // pdb to search in
    IN  TAG              tiSearchTag,   // OPTIONAL - target tag (TAG_EXE or TAG_APPHELP_EXE)
    IN  PSEARCHDBCONTEXT pContext,
    OUT TAGID*           ptiExes,       // caller needs to provide array of size SDB_MAX_EXES
    OUT GUID*            pLastExeGUID,
    OUT DWORD*           pLastExeFlags,
    IN OUT PMATCHMODE    pMatchMode     // reason why we stopped scanning
    );

void
SdbpReleaseSearchDBContext(
    PSEARCHDBCONTEXT pContext
    );



//
// this macro is used to retrieve ulonglong from the index
//
//

#if defined(_WIN64)

#define READ_INDEX_KEY(pIndexRecord, iIndex, pullKey) \
    RtlMoveMemory((pullKey), &pIndexRecord[iIndex].ullKey, sizeof(*(pullKey)))
#else

#define READ_INDEX_KEY(pIndexRecord, iIndex, pullKey) \
    *pullKey = pIndexRecord[iIndex].ullKey

#endif

#define READ_INDEX_KEY_VAL(pIndexRecord, iIndex, pullKey) \
    ( READ_INDEX_KEY(pIndexRecord, iIndex, pullKey), *(pullKey) )

//
// this macro is used to allocate cheap pointer on the stack
//

#if DBG | defined(KERNEL_MODE) | defined(_WIN64)

#define STACK_ALLOC(ptrVar, nSize) \
    {                                     \
        PVOID* ppVar = (PVOID*)&(ptrVar); \
        *ppVar = SdbAlloc(nSize);         \
    }

#define STACK_FREE(pMemory)  \
    SdbFree(pMemory)

#else // hack-routine to reset the stack after an overflow

//
// this routine is a replica of a _resetstkoflw which lives in the crt
// crtw32\heap\resetstk.c
//

VOID
SdbResetStackOverflow(
    VOID
    );


//
// HACK ALERT
//
//  The code below works because when we hit a stack overflow - we catch the exception
//  and subsequently fix the stack up using a crt routine
//

#define STACK_ALLOC(ptrVar, nSize) \
    __try {                                                                 \
        PVOID* ppVar = (PVOID*)&(ptrVar);                                   \
        *ppVar = _alloca(nSize);                                            \
    } __except (GetExceptionCode() == EXCEPTION_STACK_OVERFLOW ?            \
                EXCEPTION_EXECUTE_HANDLER:EXCEPTION_CONTINUE_SEARCH) {      \
        (ptrVar) = NULL;                                                    \
    }                                                                       \
                                                                            \
    if (ptrVar == NULL) {                                                   \
        SdbResetStackOverflow();                                                    \
    }


#define STACK_FREE(pMemory)

#endif

LPTSTR
SdbpDuplicateString(
    LPCTSTR pszSrc);



#define FDA_FILESIZE 0x00000001


BOOL
SdbpQueryFileDirectoryAttributes(
    LPCTSTR                  FilePath,
    PFILEDIRECTORYATTRIBUTES pFileDirectoryAttributes
    );

//
// Magic fileinfo signature
//
#define FILEINFO_MAGIC 0xA4C0FFEE


WCHAR*
DuplicateUnicodeString(
    IN PUNICODE_STRING pStr,
    IN PUSHORT         pLength  OPTIONAL
    );  // pLength is an allocated length

LPWSTR
StringToUnicodeString(
    IN  LPCSTR pszSrc
    );


//
// defined for uni/non-uni separately
//

BOOL
SdbpGet16BitDescription(
    LPTSTR* ppszDescription,
    PIMAGEFILEDATA pImageData
    );

BOOL
SdbpGet16BitModuleName(
    LPTSTR* ppszModuleName,
    PIMAGEFILEDATA pImageData
    );

//
// in attributes.c
//

BOOL
SdbpQuery16BitDescription(
    LPSTR szBuffer,      // min length -- 256 chars !
    PIMAGEFILEDATA pImageData
    );


BOOL
SdbpQuery16BitModuleName(
    LPSTR szBuffer,      // min length -- 256 chars !
    PIMAGEFILEDATA pImageData
    );

LPCTSTR
SdbpModuleTypeToString(
    DWORD dwModuleType
);

//
// in index.c
//

BOOL
SdbpPatternMatch(
    IN  LPCTSTR pszPattern,
    IN  LPCTSTR pszTestString);

BOOL
SdbpPatternMatchAnsi(
    IN  LPCSTR pszPattern,
    IN  LPCSTR pszTestString);

//
// defined for uni/non-uni separately
//

//////////////////////////////////////////////////////////////////////////////////
//
//  GetFileInfo
//  1. performs check on a file to determine if it exists
//  2. if it does exist -- it leaves a cache entry (creates a fileinfo struct)
//     if it does NOT exist -- we leave no mention of it on record
//  if bNoCache == TRUE the file is not entered into the cache
//  caller must free the stucture using FreeFileData
//
//  Parameters:
//      tiMatch        - IN - match id from the database, used temporary
//      FilePath    -    IN - file path that we are to check
//      bNoCache    -    IN - whether we should enter the file into cache
//
//  returns:
//      Pointer to internal data structure that should be used in
//      subsequent calls to SdbpCheckAttribute or NULL if file was not available
//

PVOID
SdbGetFileInfo(
    IN  HSDB    hSDB,
    IN  LPCTSTR pszFilePath,
    IN  HANDLE  hFile OPTIONAL,
    IN  LPVOID  pImageBase OPTIONAL,
    IN  DWORD   dwImageSize OPTIONAL,
    IN  BOOL    bNoCache
    );


//
// in attributes.c
//

PFILEINFO
CreateFileInfo(
    IN  PSDBCONTEXT pContext,
    IN  LPCTSTR     FullPath,
    IN  DWORD       dwLength OPTIONAL,  // length (in characters) of FullPath string
    IN  HANDLE      hFile OPTIONAL,   // file handle
    IN  LPVOID      pImageBase OPTIONAL,
    IN  DWORD       dwImageSize OPTIONAL,
    IN  BOOL        bNoCache
    );

PFILEINFO
FindFileInfo(
    PSDBCONTEXT pContext,
    LPCTSTR     FilePath
    );


// defined unicode and non-unicode

INT GetShimDbgLevel(VOID);


//
// from index.c
//

STRINGREF HashFindString(PSTRHASH pHash, LPCTSTR szString);

BOOL HashAddString(PSTRHASH pHash, LPCTSTR szString, STRINGREF srString);

BOOL
SdbpIsPathOnCdRom(
    LPCTSTR pszPath
    );

BOOL
SdbpBuildSignature(
    LPCTSTR pszPath,
    LPTSTR  pszPathSigned
    );

//
// in ntbase/win32base
//

DWORD
SdbpGetProcessorArchitecture(
    VOID
    );

VOID
SdbpGetOSSKU(
    LPDWORD lpdwSKU,
    LPDWORD lpdwSP
    );

//
// in Attributes.c
//

BOOL
SdbpCheckRuntimePlatform(
    IN PSDBCONTEXT pContext,   // pointer to the database channel
    IN LPCTSTR     pszMatchingFile,
    IN DWORD       dwPlatformDB
    );

//
// convenient define
//

#ifndef OFFSETOF
#define OFFSETOF offsetof
#endif


/* // Use this pragma below in conjunction with the commented block
   // in the beginning of the file to compile with warning level 4

#pragma warning(pop)

*/
#endif // __SDBP_H__