Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-05-18 16:51:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

[APPHELP][XML2SDB] Code cleanup + add assertions

Browse source 
- Always used pdb or hsdb, no more 'db'
- Add property to an PDB that describes if it's opened for read/write, and assert on this
- Add comments

svn path=/trunk/; revision=75489
This commit is contained in:
Mark Jansen 2017-08-05 12:05:06 +00:00
parent 793519c8bc
commit 7746fd43d1
12 changed files with 338 additions and 303 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
reactos/dll/appcompat/apphelp/apphelp.h
View file

@ -1,6 +1,6 @@
/* /*
* Copyright 2013 Mislav Blažević * Copyright 2013 Mislav Blažević
* Copyright 2015-2017 Mark Jansen * Copyright 2015-2017 Mark Jansen (mark.jansen@reactos.org)
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -36,7 +36,7 @@ extern "C" {
#define SDB_DATABASE_MAIN_DRIVERS 0x80040000 #define SDB_DATABASE_MAIN_DRIVERS 0x80040000
typedef struct _SDB { typedef struct _SDB {
PDB db; PDB pdb;
BOOL auto_loaded; BOOL auto_loaded;
} SDB, *HSDB; } SDB, *HSDB;
@ -98,19 +98,19 @@ PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type);
void WINAPI SdbCloseDatabase(PDB); void WINAPI SdbCloseDatabase(PDB);
BOOL WINAPI SdbIsNullGUID(CONST GUID *Guid); BOOL WINAPI SdbIsNullGUID(CONST GUID *Guid);
BOOL WINAPI SdbGetAppPatchDir(HSDB db, LPWSTR path, DWORD size); BOOL WINAPI SdbGetAppPatchDir(HSDB db, LPWSTR path, DWORD size);
LPWSTR WINAPI SdbGetStringTagPtr(PDB db, TAGID tagid); LPWSTR WINAPI SdbGetStringTagPtr(PDB pdb, TAGID tagid);
TAGID WINAPI SdbFindFirstNamedTag(PDB db, TAGID root, TAGID find, TAGID nametag, LPCWSTR find_name); TAGID WINAPI SdbFindFirstNamedTag(PDB pdb, TAGID root, TAGID find, TAGID nametag, LPCWSTR find_name);
/* sdbread.c */ /* sdbread.c */
BOOL WINAPI SdbpReadData(PDB db, PVOID dest, DWORD offset, DWORD num); BOOL WINAPI SdbpReadData(PDB pdb, PVOID dest, DWORD offset, DWORD num);
TAG WINAPI SdbGetTagFromTagID(PDB db, TAGID tagid); TAG WINAPI SdbGetTagFromTagID(PDB pdb, TAGID tagid);
TAGID WINAPI SdbFindFirstTag(PDB db, TAGID parent, TAG tag); TAGID WINAPI SdbFindFirstTag(PDB pdb, TAGID parent, TAG tag);
TAGID WINAPI SdbFindNextTag(PDB db, TAGID parent, TAGID prev_child); TAGID WINAPI SdbFindNextTag(PDB pdb, TAGID parent, TAGID prev_child);
BOOL WINAPI SdbGetDatabaseID(PDB db, GUID* Guid); BOOL WINAPI SdbGetDatabaseID(PDB pdb, GUID* Guid);
DWORD WINAPI SdbReadDWORDTag(PDB db, TAGID tagid, DWORD ret); DWORD WINAPI SdbReadDWORDTag(PDB pdb, TAGID tagid, DWORD ret);
QWORD WINAPI SdbReadQWORDTag(PDB db, TAGID tagid, QWORD ret); QWORD WINAPI SdbReadQWORDTag(PDB pdb, TAGID tagid, QWORD ret);
TAGID WINAPI SdbGetFirstChild(PDB db, TAGID parent); TAGID WINAPI SdbGetFirstChild(PDB pdb, TAGID parent);
TAGID WINAPI SdbGetNextChild(PDB db, TAGID parent, TAGID prev_child); TAGID WINAPI SdbGetNextChild(PDB pdb, TAGID parent, TAGID prev_child);
/* sdbfileattr.c*/ /* sdbfileattr.c*/
BOOL WINAPI SdbGetFileAttributes(LPCWSTR path, PATTRINFO *attr_info_ret, LPDWORD attr_count); BOOL WINAPI SdbGetFileAttributes(LPCWSTR path, PATTRINFO *attr_info_ret, LPDWORD attr_count);

97
reactos/dll/appcompat/apphelp/hsdb.c
View file

@ -48,6 +48,8 @@ static BOOL WINAPI SdbpFileExists(LPCWSTR path)
return (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY)); return (attr != INVALID_FILE_ATTRIBUTES && !(attr & FILE_ATTRIBUTE_DIRECTORY));
} }
/* Given a 'MATCHING_FILE' tag and an ATTRINFO array,
check all tags defined in the MATCHING_FILE against the ATTRINFO */
static BOOL SdbpMatchFileAttributes(PDB pdb, TAGID matching_file, PATTRINFO attribs, DWORD attr_count) static BOOL SdbpMatchFileAttributes(PDB pdb, TAGID matching_file, PATTRINFO attribs, DWORD attr_count)
{ {
TAGID child; TAGID child;
@ -107,6 +109,8 @@ static BOOL SdbpMatchFileAttributes(PDB pdb, TAGID matching_file, PATTRINFO attr
return TRUE; return TRUE;
} }
/* Given an 'exe' tag and an ATTRINFO array (for the main file),
verify that the main file and any additional files match */
static BOOL WINAPI SdbpMatchExe(PDB pdb, TAGID exe, const WCHAR* dir, PATTRINFO main_attribs, DWORD main_attr_count) static BOOL WINAPI SdbpMatchExe(PDB pdb, TAGID exe, const WCHAR* dir, PATTRINFO main_attribs, DWORD main_attr_count)
{ {
RTL_UNICODE_STRING_BUFFER FullPathName = { { 0 } }; RTL_UNICODE_STRING_BUFFER FullPathName = { { 0 } };
@ -132,8 +136,10 @@ static BOOL WINAPI SdbpMatchExe(PDB pdb, TAGID exe, const WCHAR* dir, PATTRINFO
if (!Name.Buffer) if (!Name.Buffer)
goto Cleanup; goto Cleanup;
/* An '*' here means use the main executable' */
if (!wcscmp(Name.Buffer, L"*")) if (!wcscmp(Name.Buffer, L"*"))
{ {
/* We already have these attributes, so we do not need to retrieve them */
if (!SdbpMatchFileAttributes(pdb, matching_file, main_attribs, main_attr_count)) if (!SdbpMatchFileAttributes(pdb, matching_file, main_attribs, main_attr_count))
goto Cleanup; goto Cleanup;
continue; continue;
@ -153,9 +159,11 @@ static BOOL WINAPI SdbpMatchExe(PDB pdb, TAGID exe, const WCHAR* dir, PATTRINFO
RtlAppendUnicodeToString(&FullPathName.String, L"\\"); RtlAppendUnicodeToString(&FullPathName.String, L"\\");
RtlAppendUnicodeStringToString(&FullPathName.String, &Name); RtlAppendUnicodeStringToString(&FullPathName.String, &Name);
/* If the file does not exist, do not bother trying to read it's attributes */
if (!SdbpFileExists(FullPathName.String.Buffer)) if (!SdbpFileExists(FullPathName.String.Buffer))
goto Cleanup; goto Cleanup;
/* Do we have some attributes from the previous iteration? */
if (attribs) if (attribs)
SdbFreeFileAttributes(attribs); SdbFreeFileAttributes(attribs);
@ -176,24 +184,26 @@ Cleanup:
return IsMatch; return IsMatch;
} }
static void SdbpAddDatabaseGuid(PDB db, PSDBQUERYRESULT result) /* Add a database guid to the query result */
static void SdbpAddDatabaseGuid(PDB pdb, PSDBQUERYRESULT result)
{ {
size_t n; size_t n;
for (n = 0; n < _countof(result->rgGuidDB); ++n) for (n = 0; n < _countof(result->rgGuidDB); ++n)
{ {
if (!memcmp(&result->rgGuidDB[n], &db->database_id, sizeof(db->database_id))) if (!memcmp(&result->rgGuidDB[n], &pdb->database_id, sizeof(pdb->database_id)))
return; return;
if (result->dwCustomSDBMap & (1<<n)) if (result->dwCustomSDBMap & (1<<n))
continue; continue;
memcpy(&result->rgGuidDB[n], &db->database_id, sizeof(result->rgGuidDB[n])); memcpy(&result->rgGuidDB[n], &pdb->database_id, sizeof(result->rgGuidDB[n]));
result->dwCustomSDBMap |= (1<<n); result->dwCustomSDBMap |= (1<<n);
return; return;
} }
} }
/* Add one layer to the query result */
static BOOL SdbpAddSingleLayerMatch(TAGREF layer, PSDBQUERYRESULT result) static BOOL SdbpAddSingleLayerMatch(TAGREF layer, PSDBQUERYRESULT result)
{ {
size_t n; size_t n;
@ -213,54 +223,55 @@ static BOOL SdbpAddSingleLayerMatch(TAGREF layer, PSDBQUERYRESULT result)
return TRUE; return TRUE;
} }
/* Translate a layer name to a tagref + add it to the query result */
static BOOL SdbpAddNamedLayerMatch(HSDB hsdb, PCWSTR layerName, PSDBQUERYRESULT result) static BOOL SdbpAddNamedLayerMatch(HSDB hsdb, PCWSTR layerName, PSDBQUERYRESULT result)
{ {
TAGID database, layer; TAGID database, layer;
TAGREF tr; TAGREF tr;
PDB db = hsdb->db; PDB pdb = hsdb->pdb;
database = SdbFindFirstTag(db, TAGID_ROOT, TAG_DATABASE); database = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
if (database == TAGID_NULL) if (database == TAGID_NULL)
return FALSE; return FALSE;
layer = SdbFindFirstNamedTag(db, database, TAG_LAYER, TAG_NAME, layerName); layer = SdbFindFirstNamedTag(pdb, database, TAG_LAYER, TAG_NAME, layerName);
if (layer == TAGID_NULL) if (layer == TAGID_NULL)
return FALSE; return FALSE;
if (!SdbTagIDToTagRef(hsdb, db, layer, &tr)) if (!SdbTagIDToTagRef(hsdb, pdb, layer, &tr))
return FALSE; return FALSE;
if (!SdbpAddSingleLayerMatch(tr, result)) if (!SdbpAddSingleLayerMatch(tr, result))
return FALSE; return FALSE;
SdbpAddDatabaseGuid(db, result); SdbpAddDatabaseGuid(pdb, result);
return TRUE; return TRUE;
} }
static void SdbpAddExeLayers(HSDB hsdb, PDB db, TAGID tagExe, PSDBQUERYRESULT result) /* Add all layers for the exe tag to the query result */
static void SdbpAddExeLayers(HSDB hsdb, PDB pdb, TAGID tagExe, PSDBQUERYRESULT result)
{ {
TAGID layer = SdbFindFirstTag(db, tagExe, TAG_LAYER); TAGID layer = SdbFindFirstTag(pdb, tagExe, TAG_LAYER);
while (layer != TAGID_NULL) while (layer != TAGID_NULL)
{ {
TAGREF tr; TAGREF tr;
TAGID layerIdTag = SdbFindFirstTag(db, layer, TAG_LAYER_TAGID); TAGID layerIdTag = SdbFindFirstTag(pdb, layer, TAG_LAYER_TAGID);
DWORD tagId = SdbReadDWORDTag(db, layerIdTag, TAGID_NULL); DWORD tagId = SdbReadDWORDTag(pdb, layerIdTag, TAGID_NULL);
if (layerIdTag != TAGID_NULL && if (layerIdTag != TAGID_NULL &&
tagId != TAGID_NULL && tagId != TAGID_NULL &&
SdbTagIDToTagRef(hsdb, db, tagId, &tr)) SdbTagIDToTagRef(hsdb, pdb, tagId, &tr))
{ {
SdbpAddSingleLayerMatch(tr, result); SdbpAddSingleLayerMatch(tr, result);
} }
else else
{ {
/* Try a name lookup */ /* Try a name lookup */
TAGID layerTag = SdbFindFirstTag(db, layer, TAG_NAME); TAGID layerTag = SdbFindFirstTag(pdb, layer, TAG_NAME);
if (layerTag != TAGID_NULL) if (layerTag != TAGID_NULL)
{ {
LPCWSTR layerName = SdbGetStringTagPtr(db, layerTag); LPCWSTR layerName = SdbGetStringTagPtr(pdb, layerTag);
if (layerName) if (layerName)
{ {
SdbpAddNamedLayerMatch(hsdb, layerName, result); SdbpAddNamedLayerMatch(hsdb, layerName, result);
@ -268,16 +279,17 @@ static void SdbpAddExeLayers(HSDB hsdb, PDB db, TAGID tagExe, PSDBQUERYRESULT re
} }
} }
layer = SdbFindNextTag(db, tagExe, layer); layer = SdbFindNextTag(pdb, tagExe, layer);
} }
} }
static void SdbpAddExeMatch(HSDB hsdb, PDB db, TAGID tagExe, PSDBQUERYRESULT result) /* Add an exe tag to the query result */
static void SdbpAddExeMatch(HSDB hsdb, PDB pdb, TAGID tagExe, PSDBQUERYRESULT result)
{ {
size_t n; size_t n;
TAGREF tr; TAGREF tr;
if (!SdbTagIDToTagRef(hsdb, db, tagExe, &tr)) if (!SdbTagIDToTagRef(hsdb, pdb, tagExe, &tr))
return; return;
for (n = 0; n < result->dwExeCount; ++n) for (n = 0; n < result->dwExeCount; ++n)
@ -292,11 +304,12 @@ static void SdbpAddExeMatch(HSDB hsdb, PDB db, TAGID tagExe, PSDBQUERYRESULT res
result->atrExes[n] = tr; result->atrExes[n] = tr;
result->dwExeCount++; result->dwExeCount++;
SdbpAddExeLayers(hsdb, db, tagExe, result); SdbpAddExeLayers(hsdb, pdb, tagExe, result);
SdbpAddDatabaseGuid(db, result); SdbpAddDatabaseGuid(pdb, result);
} }
/* Add all named layers to the query result */
static ULONG SdbpAddLayerMatches(HSDB hsdb, PWSTR pwszLayers, DWORD pdwBytes, PSDBQUERYRESULT result) static ULONG SdbpAddLayerMatches(HSDB hsdb, PWSTR pwszLayers, DWORD pdwBytes, PSDBQUERYRESULT result)
{ {
PWSTR start = pwszLayers, p; PWSTR start = pwszLayers, p;
@ -350,7 +363,7 @@ static BOOL SdbpPropagateEnvLayers(HSDB hsdb, LPWSTR Environment, PSDBQUERYRESUL
/** /**
* Opens specified shim database file Handle returned by this function may only be used by * Opens specified shim database file. Handle returned by this function may only be used by
* functions which take HSDB param thus differing it from SdbOpenDatabase. * functions which take HSDB param thus differing it from SdbOpenDatabase.
* *
* @param [in] flags Specifies type of path or predefined database. * @param [in] flags Specifies type of path or predefined database.
@ -389,10 +402,10 @@ HSDB WINAPI SdbInitDatabase(DWORD flags, LPCWSTR path)
flags = HID_DOS_PATHS; flags = HID_DOS_PATHS;
} }
hsdb->db = SdbOpenDatabase(path ? path : buffer, (flags & 0xF) - 1); hsdb->pdb = SdbOpenDatabase(path ? path : buffer, (flags & 0xF) - 1);
/* If database could not be loaded, a handle doesn't make sense either */ /* If database could not be loaded, a handle doesn't make sense either */
if (!hsdb->db) if (!hsdb->pdb)
{ {
SdbReleaseDatabase(hsdb); SdbReleaseDatabase(hsdb);
return NULL; return NULL;
@ -408,7 +421,7 @@ HSDB WINAPI SdbInitDatabase(DWORD flags, LPCWSTR path)
*/ */
void WINAPI SdbReleaseDatabase(HSDB hsdb) void WINAPI SdbReleaseDatabase(HSDB hsdb)
{ {
SdbCloseDatabase(hsdb->db); SdbCloseDatabase(hsdb->pdb);
SdbFree(hsdb); SdbFree(hsdb);
} }
@ -438,7 +451,7 @@ BOOL WINAPI SdbGetMatchingExe(HSDB hsdb, LPCWSTR path, LPCWSTR module_name,
LPWSTR file_name; LPWSTR file_name;
WCHAR wszLayers[MAX_LAYER_LENGTH]; WCHAR wszLayers[MAX_LAYER_LENGTH];
DWORD dwSize; DWORD dwSize;
PDB db; PDB pdb;
/* Load default database if one is not specified */ /* Load default database if one is not specified */
if (!hsdb) if (!hsdb)
@ -457,7 +470,7 @@ BOOL WINAPI SdbGetMatchingExe(HSDB hsdb, LPCWSTR path, LPCWSTR module_name,
return FALSE; return FALSE;
/* We do not support multiple db's yet! */ /* We do not support multiple db's yet! */
db = hsdb->db; pdb = hsdb->pdb;
RtlInitUnicodeString(&DosApplicationName.String, path); RtlInitUnicodeString(&DosApplicationName.String, path);
RtlInitBuffer(&DosApplicationName.ByteBuffer, (PUCHAR)DosPathBuffer, sizeof(DosPathBuffer)); RtlInitBuffer(&DosApplicationName.ByteBuffer, (PUCHAR)DosPathBuffer, sizeof(DosPathBuffer));
@ -491,24 +504,24 @@ BOOL WINAPI SdbGetMatchingExe(HSDB hsdb, LPCWSTR path, LPCWSTR module_name,
*(file_name++) = UNICODE_NULL; *(file_name++) = UNICODE_NULL;
/* DATABASE is list TAG which contains all executables */ /* DATABASE is list TAG which contains all executables */
database = SdbFindFirstTag(db, TAGID_ROOT, TAG_DATABASE); database = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
if (database == TAGID_NULL) if (database == TAGID_NULL)
{ {
goto Cleanup; goto Cleanup;
} }
/* EXE is list TAG which contains data required to match executable */ /* EXE is list TAG which contains data required to match executable */
iter = SdbFindFirstTag(db, database, TAG_EXE); iter = SdbFindFirstTag(pdb, database, TAG_EXE);
/* Search for entry in database, we should look into indexing tags! */ /* Search for entry in database, we should look into indexing tags! */
while (iter != TAGID_NULL) while (iter != TAGID_NULL)
{ {
LPWSTR foundName; LPWSTR foundName;
/* Check if exe name matches */ /* Check if exe name matches */
name = SdbFindFirstTag(db, iter, TAG_NAME); name = SdbFindFirstTag(pdb, iter, TAG_NAME);
/* If this is a malformed DB, (no TAG_NAME), we should not crash. */ /* If this is a malformed DB, (no TAG_NAME), we should not crash. */
foundName = SdbGetStringTagPtr(db, name); foundName = SdbGetStringTagPtr(pdb, name);
if (foundName && !lstrcmpiW(foundName, file_name)) if (foundName && !wcsicmp(foundName, file_name))
{ {
/* Get information about executable required to match it with database entry */ /* Get information about executable required to match it with database entry */
if (!attribs) if (!attribs)
@ -519,15 +532,15 @@ BOOL WINAPI SdbGetMatchingExe(HSDB hsdb, LPCWSTR path, LPCWSTR module_name,
/* We have a null terminator before the application name, so DosApplicationName only contains the path. */ /* We have a null terminator before the application name, so DosApplicationName only contains the path. */
if (SdbpMatchExe(db, iter, DosApplicationName.String.Buffer, attribs, attr_count)) if (SdbpMatchExe(pdb, iter, DosApplicationName.String.Buffer, attribs, attr_count))
{ {
ret = TRUE; ret = TRUE;
SdbpAddExeMatch(hsdb, db, iter, result); SdbpAddExeMatch(hsdb, pdb, iter, result);
} }
} }
/* Continue iterating */ /* Continue iterating */
iter = SdbFindNextTag(db, database, iter); iter = SdbFindNextTag(pdb, database, iter);
} }
/* Restore the full path. */ /* Restore the full path. */
@ -561,11 +574,11 @@ Cleanup:
/** /**
* Retrieves AppPatch directory. * Retrieves AppPatch directory.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [out] path Pointer to memory in which path shall be written. * @param [out] path Pointer to memory in which path shall be written.
* @param [in] size Size of the buffer in characters. * @param [in] size Size of the buffer in characters.
*/ */
BOOL WINAPI SdbGetAppPatchDir(HSDB db, LPWSTR path, DWORD size) BOOL WINAPI SdbGetAppPatchDir(HSDB hsdb, LPWSTR path, DWORD size)
{ {
static WCHAR* default_dir = NULL; static WCHAR* default_dir = NULL;
static CONST WCHAR szAppPatch[] = {'\\','A','p','p','P','a','t','c','h',0}; static CONST WCHAR szAppPatch[] = {'\\','A','p','p','P','a','t','c','h',0};
@ -600,13 +613,13 @@ BOOL WINAPI SdbGetAppPatchDir(HSDB db, LPWSTR path, DWORD size)
} }
} }
if (!db) if (!hsdb)
{ {
return SUCCEEDED(StringCchCopyW(path, size, default_dir)); return SUCCEEDED(StringCchCopyW(path, size, default_dir));
} }
else else
{ {
SHIM_ERR("Unimplemented for db != NULL\n"); SHIM_ERR("Unimplemented for hsdb != NULL\n");
return FALSE; return FALSE;
} }
} }
@ -636,7 +649,7 @@ BOOL WINAPI SdbTagRefToTagID(HSDB hsdb, TAGREF trWhich, PDB* ppdb, TAGID* ptiWhi
/* There seems to be no range checking on trWhich.. */ /* There seems to be no range checking on trWhich.. */
if (ppdb) if (ppdb)
*ppdb = hsdb->db; *ppdb = hsdb->pdb;
if (ptiWhich) if (ptiWhich)
*ptiWhich = trWhich & 0x0fffffff; *ptiWhich = trWhich & 0x0fffffff;
@ -655,7 +668,7 @@ BOOL WINAPI SdbTagRefToTagID(HSDB hsdb, TAGREF trWhich, PDB* ppdb, TAGID* ptiWhi
*/ */
BOOL WINAPI SdbTagIDToTagRef(HSDB hsdb, PDB pdb, TAGID tiWhich, TAGREF* ptrWhich) BOOL WINAPI SdbTagIDToTagRef(HSDB hsdb, PDB pdb, TAGID tiWhich, TAGREF* ptrWhich)
{ {
if (pdb != hsdb->db) if (pdb != hsdb->pdb)
{ {
SHIM_ERR("Multiple shim databases not yet implemented!\n"); SHIM_ERR("Multiple shim databases not yet implemented!\n");
if (ptrWhich) if (ptrWhich)
@ -670,7 +683,7 @@ BOOL WINAPI SdbTagIDToTagRef(HSDB hsdb, PDB pdb, TAGID tiWhich, TAGREF* ptrWhich
} }
/* Convert a query result to shim data that will be loaded in the child process */
BOOL WINAPI SdbPackAppCompatData(HSDB hsdb, PSDBQUERYRESULT pQueryResult, PVOID* ppData, DWORD *pdwSize) BOOL WINAPI SdbPackAppCompatData(HSDB hsdb, PSDBQUERYRESULT pQueryResult, PVOID* ppData, DWORD *pdwSize)
{ {
ShimData* pData; ShimData* pData;

4
reactos/dll/appcompat/apphelp/layer.c
View file

@ -50,7 +50,7 @@
#define SIGN_MEDIA_FMT L"SIGN.MEDIA=%X %s" #define SIGN_MEDIA_FMT L"SIGN.MEDIA=%X %s"
#endif #endif
/* Fixme: use RTL_UNICODE_STRING_BUFFER */
typedef struct SDB_TMP_STR typedef struct SDB_TMP_STR
{ {
UNICODE_STRING Str; UNICODE_STRING Str;
@ -131,6 +131,7 @@ BOOL SdbpIsPathOnRemovableMedia(PCWSTR Path)
return type == DRIVE_REMOVABLE || type == DRIVE_CDROM; return type == DRIVE_REMOVABLE || type == DRIVE_CDROM;
} }
/* Convert a path on removable media to 'SIGN.MEDIA=%X filename' */
BOOL SdbpBuildSignMediaId(PSDB_TMP_STR LongPath) BOOL SdbpBuildSignMediaId(PSDB_TMP_STR LongPath)
{ {
SDB_TMP_STR Scratch; SDB_TMP_STR Scratch;
@ -169,6 +170,7 @@ BOOL SdbpBuildSignMediaId(PSDB_TMP_STR LongPath)
return FALSE; return FALSE;
} }
/* Convert a given path to a long or media path */
BOOL SdbpResolvePath(PSDB_TMP_STR LongPath, PCWSTR wszPath) BOOL SdbpResolvePath(PSDB_TMP_STR LongPath, PCWSTR wszPath)
{ {
SdbpInitTempStr(LongPath); SdbpInitTempStr(LongPath);

115
reactos/dll/appcompat/apphelp/sdbapi.c
View file

@ -107,7 +107,7 @@ PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write)
IO_STATUS_BLOCK io; IO_STATUS_BLOCK io;
OBJECT_ATTRIBUTES attr; OBJECT_ATTRIBUTES attr;
UNICODE_STRING str; UNICODE_STRING str;
PDB db; PDB pdb;
if (type == DOS_PATH) if (type == DOS_PATH)
{ {
@ -120,8 +120,8 @@ PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write)
} }
/* SdbAlloc zeroes the memory. */ /* SdbAlloc zeroes the memory. */
db = (PDB)SdbAlloc(sizeof(DB)); pdb = (PDB)SdbAlloc(sizeof(DB));
if (!db) if (!pdb)
{ {
SHIM_ERR("Failed to allocate memory for shim database\n"); SHIM_ERR("Failed to allocate memory for shim database\n");
return NULL; return NULL;
@ -129,28 +129,33 @@ PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write)
InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, NULL, NULL); InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, NULL, NULL);
Status = NtCreateFile(&db->file, (write ? FILE_GENERIC_WRITE : FILE_GENERIC_READ )| SYNCHRONIZE, Status = NtCreateFile(&pdb->file, (write ? FILE_GENERIC_WRITE : FILE_GENERIC_READ )| SYNCHRONIZE,
&attr, &io, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ, &attr, &io, NULL, FILE_ATTRIBUTE_NORMAL, FILE_SHARE_READ,
write ? FILE_SUPERSEDE : FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0); write ? FILE_SUPERSEDE : FILE_OPEN, FILE_NON_DIRECTORY_FILE | FILE_SYNCHRONOUS_IO_NONALERT, NULL, 0);
pdb->for_write = write;
if (type == DOS_PATH) if (type == DOS_PATH)
RtlFreeUnicodeString(&str); RtlFreeUnicodeString(&str);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
SHIM_ERR("Failed to create shim database file: %lx\n", Status); SHIM_ERR("Failed to create shim database file: %lx\n", Status);
return NULL; return NULL;
} }
return db; return pdb;
} }
void WINAPI SdbpFlush(PDB db) void WINAPI SdbpFlush(PDB pdb)
{ {
IO_STATUS_BLOCK io; IO_STATUS_BLOCK io;
NTSTATUS Status = NtWriteFile(db->file, NULL, NULL, NULL, &io, NTSTATUS Status;
db->data, db->write_iter, NULL, NULL);
ASSERT(pdb->for_write);
Status = NtWriteFile(pdb->file, NULL, NULL, NULL, &io,
pdb->data, pdb->write_iter, NULL, NULL);
if( !NT_SUCCESS(Status)) if( !NT_SUCCESS(Status))
SHIM_WARN("failed with 0x%lx\n", Status); SHIM_WARN("failed with 0x%lx\n", Status);
} }
@ -257,9 +262,9 @@ BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type)
return TRUE; return TRUE;
} }
BOOL WINAPI SdbpCheckTagIDType(PDB db, TAGID tagid, WORD type) BOOL WINAPI SdbpCheckTagIDType(PDB pdb, TAGID tagid, WORD type)
{ {
TAG tag = SdbGetTagFromTagID(db, tagid); TAG tag = SdbGetTagFromTagID(pdb, tagid);
if (tag == TAG_NULL) if (tag == TAG_NULL)
return FALSE; return FALSE;
return SdbpCheckTagType(tag, type); return SdbpCheckTagType(tag, type);
@ -269,43 +274,43 @@ PDB SdbpOpenDatabase(LPCWSTR path, PATH_TYPE type, PDWORD major, PDWORD minor)
{ {
IO_STATUS_BLOCK io; IO_STATUS_BLOCK io;
FILE_STANDARD_INFORMATION fsi; FILE_STANDARD_INFORMATION fsi;
PDB db; PDB pdb;
NTSTATUS Status; NTSTATUS Status;
BYTE header[12]; BYTE header[12];
db = SdbpCreate(path, type, FALSE); pdb = SdbpCreate(path, type, FALSE);
if (!db) if (!pdb)
return NULL; return NULL;
Status = NtQueryInformationFile(db->file, &io, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation); Status = NtQueryInformationFile(pdb->file, &io, &fsi, sizeof(FILE_STANDARD_INFORMATION), FileStandardInformation);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
SHIM_ERR("Failed to get shim database size: 0x%lx\n", Status); SHIM_ERR("Failed to get shim database size: 0x%lx\n", Status);
return NULL; return NULL;
} }
db->size = fsi.EndOfFile.u.LowPart; pdb->size = fsi.EndOfFile.u.LowPart;
db->data = SdbAlloc(db->size); pdb->data = SdbAlloc(pdb->size);
Status = NtReadFile(db->file, NULL, NULL, NULL, &io, db->data, db->size, NULL, NULL); Status = NtReadFile(pdb->file, NULL, NULL, NULL, &io, pdb->data, pdb->size, NULL, NULL);
if (!NT_SUCCESS(Status)) if (!NT_SUCCESS(Status))
{ {
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
SHIM_ERR("Failed to open shim database file: 0x%lx\n", Status); SHIM_ERR("Failed to open shim database file: 0x%lx\n", Status);
return NULL; return NULL;
} }
if (!SdbpReadData(db, &header, 0, 12)) if (!SdbpReadData(pdb, &header, 0, 12))
{ {
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
SHIM_ERR("Failed to read shim database header\n"); SHIM_ERR("Failed to read shim database header\n");
return NULL; return NULL;
} }
if (memcmp(&header[8], "sdbf", 4) != 0) if (memcmp(&header[8], "sdbf", 4) != 0)
{ {
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
SHIM_ERR("Shim database header is invalid\n"); SHIM_ERR("Shim database header is invalid\n");
return NULL; return NULL;
} }
@ -313,7 +318,7 @@ PDB SdbpOpenDatabase(LPCWSTR path, PATH_TYPE type, PDWORD major, PDWORD minor)
*major = *(DWORD*)&header[0]; *major = *(DWORD*)&header[0];
*minor = *(DWORD*)&header[4]; *minor = *(DWORD*)&header[4];
return db; return pdb;
} }
@ -327,46 +332,46 @@ PDB SdbpOpenDatabase(LPCWSTR path, PATH_TYPE type, PDWORD major, PDWORD minor)
*/ */
PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type) PDB WINAPI SdbOpenDatabase(LPCWSTR path, PATH_TYPE type)
{ {
PDB db; PDB pdb;
DWORD major, minor; DWORD major, minor;
db = SdbpOpenDatabase(path, type, &major, &minor); pdb = SdbpOpenDatabase(path, type, &major, &minor);
if (!db) if (!pdb)
return NULL; return NULL;
if (major != 2 && major != 3) if (major != 2 && major != 3)
{ {
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
SHIM_ERR("Invalid shim database version\n"); SHIM_ERR("Invalid shim database version\n");
return NULL; return NULL;
} }
db->stringtable = SdbFindFirstTag(db, TAGID_ROOT, TAG_STRINGTABLE); pdb->stringtable = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_STRINGTABLE);
if(!SdbGetDatabaseID(db, &db->database_id)) if(!SdbGetDatabaseID(pdb, &pdb->database_id))
{ {
SHIM_INFO("Failed to get the database id\n"); SHIM_INFO("Failed to get the database id\n");
} }
return db; return pdb;
} }
/** /**
* Closes specified database and frees its memory. * Closes specified database and frees its memory.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
*/ */
void WINAPI SdbCloseDatabase(PDB db) void WINAPI SdbCloseDatabase(PDB pdb)
{ {
if (!db) if (!pdb)
return; return;
if (db->file) if (pdb->file)
NtClose(db->file); NtClose(pdb->file);
if (db->string_buffer) if (pdb->string_buffer)
SdbCloseDatabase(db->string_buffer); SdbCloseDatabase(pdb->string_buffer);
if (db->string_lookup) if (pdb->string_lookup)
SdbpTableDestroy(&db->string_lookup); SdbpTableDestroy(&pdb->string_lookup);
SdbFree(db->data); SdbFree(pdb->data);
SdbFree(db); SdbFree(pdb);
} }
/** /**
@ -462,11 +467,11 @@ BOOL WINAPI SdbGetStandardDatabaseGUID(DWORD Flags, GUID* Guid)
*/ */
BOOL WINAPI SdbGetDatabaseVersion(LPCWSTR database, PDWORD VersionHi, PDWORD VersionLo) BOOL WINAPI SdbGetDatabaseVersion(LPCWSTR database, PDWORD VersionHi, PDWORD VersionLo)
{ {
PDB db; PDB pdb;
db = SdbpOpenDatabase(database, DOS_PATH, VersionHi, VersionLo); pdb = SdbpOpenDatabase(database, DOS_PATH, VersionHi, VersionLo);
if (db) if (pdb)
SdbCloseDatabase(db); SdbCloseDatabase(pdb);
return TRUE; return TRUE;
} }
@ -483,22 +488,22 @@ BOOL WINAPI SdbGetDatabaseVersion(LPCWSTR database, PDWORD VersionHi, PDWORD Ver
* *
* @return The found tag, or TAGID_NULL on failure * @return The found tag, or TAGID_NULL on failure
*/ */
TAGID WINAPI SdbFindFirstNamedTag(PDB db, TAGID root, TAGID find, TAGID nametag, LPCWSTR find_name) TAGID WINAPI SdbFindFirstNamedTag(PDB pdb, TAGID root, TAGID find, TAGID nametag, LPCWSTR find_name)
{ {
TAGID iter; TAGID iter;
iter = SdbFindFirstTag(db, root, find); iter = SdbFindFirstTag(pdb, root, find);
while (iter != TAGID_NULL) while (iter != TAGID_NULL)
{ {
TAGID tmp = SdbFindFirstTag(db, iter, nametag); TAGID tmp = SdbFindFirstTag(pdb, iter, nametag);
if (tmp != TAGID_NULL) if (tmp != TAGID_NULL)
{ {
LPCWSTR name = SdbGetStringTagPtr(db, tmp); LPCWSTR name = SdbGetStringTagPtr(pdb, tmp);
if (name && !wcsicmp(name, find_name)) if (name && !wcsicmp(name, find_name))
return iter; return iter;
} }
iter = SdbFindNextTag(db, root, iter); iter = SdbFindNextTag(pdb, root, iter);
} }
return TAGID_NULL; return TAGID_NULL;
} }
@ -514,16 +519,16 @@ TAGID WINAPI SdbFindFirstNamedTag(PDB db, TAGID root, TAGID find, TAGID nametag,
*/ */
TAGREF WINAPI SdbGetLayerTagRef(HSDB hsdb, LPCWSTR layerName) TAGREF WINAPI SdbGetLayerTagRef(HSDB hsdb, LPCWSTR layerName)
{ {
PDB db = hsdb->db; PDB pdb = hsdb->pdb;
TAGID database = SdbFindFirstTag(db, TAGID_ROOT, TAG_DATABASE); TAGID database = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
if (database != TAGID_NULL) if (database != TAGID_NULL)
{ {
TAGID layer = SdbFindFirstNamedTag(db, database, TAG_LAYER, TAG_NAME, layerName); TAGID layer = SdbFindFirstNamedTag(pdb, database, TAG_LAYER, TAG_NAME, layerName);
if (layer != TAGID_NULL) if (layer != TAGID_NULL)
{ {
TAGREF tr; TAGREF tr;
if (SdbTagIDToTagRef(hsdb, db, layer, &tr)) if (SdbTagIDToTagRef(hsdb, pdb, layer, &tr))
{ {
return tr; return tr;
} }

6
reactos/dll/appcompat/apphelp/sdbpapi.h
View file

@ -1,6 +1,6 @@
/* /*
* Copyright 2013 Mislav Blažević * Copyright 2013 Mislav Blažević
* Copyright 2015,2016 Mark Jansen * Copyright 2015-2017 Mark Jansen (mark.jansen@reactos.org)
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -64,12 +64,12 @@ void WINAPI SdbpCloseMemMappedFile(PMEMMAPPED mapping);
PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write); PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write);
void WINAPI SdbpFlush(PDB db); void WINAPI SdbpFlush(PDB pdb);
DWORD SdbpStrlen(PCWSTR string); DWORD SdbpStrlen(PCWSTR string);
DWORD SdbpStrsize(PCWSTR string); DWORD SdbpStrsize(PCWSTR string);
BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type); BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type);
BOOL WINAPI SdbpCheckTagIDType(PDB db, TAGID tagid, WORD type); BOOL WINAPI SdbpCheckTagIDType(PDB pdb, TAGID tagid, WORD type);
#ifndef WINAPIV #ifndef WINAPIV
#define WINAPIV #define WINAPIV

154
reactos/dll/appcompat/apphelp/sdbread.c
View file

@ -22,10 +22,10 @@
#include "apphelp.h" #include "apphelp.h"
DWORD WINAPI SdbGetTagDataSize(PDB db, TAGID tagid); DWORD WINAPI SdbGetTagDataSize(PDB pdb, TAGID tagid);
BOOL WINAPI SdbpReadData(PDB db, PVOID dest, DWORD offset, DWORD num) BOOL WINAPI SdbpReadData(PDB pdb, PVOID dest, DWORD offset, DWORD num)
{ {
DWORD size = offset + num; DWORD size = offset + num;
@ -34,23 +34,23 @@ BOOL WINAPI SdbpReadData(PDB db, PVOID dest, DWORD offset, DWORD num)
return FALSE; return FALSE;
/* Overflow */ /* Overflow */
if (db->size < size) if (pdb->size < size)
return FALSE; return FALSE;
memcpy(dest, db->data + offset, num); memcpy(dest, pdb->data + offset, num);
return TRUE; return TRUE;
} }
static DWORD WINAPI SdbpGetTagSize(PDB db, TAGID tagid) static DWORD WINAPI SdbpGetTagSize(PDB pdb, TAGID tagid)
{ {
WORD type; WORD type;
DWORD size; DWORD size;
type = SdbGetTagFromTagID(db, tagid) & TAG_TYPE_MASK; type = SdbGetTagFromTagID(pdb, tagid) & TAG_TYPE_MASK;
if (type == TAG_NULL) if (type == TAG_NULL)
return 0; return 0;
size = SdbGetTagDataSize(db, tagid); size = SdbGetTagDataSize(pdb, tagid);
if (type <= TAG_TYPE_STRINGREF) if (type <= TAG_TYPE_STRINGREF)
return size += sizeof(TAG); return size += sizeof(TAG);
else size += (sizeof(TAG) + sizeof(DWORD)); else size += (sizeof(TAG) + sizeof(DWORD));
@ -58,26 +58,26 @@ static DWORD WINAPI SdbpGetTagSize(PDB db, TAGID tagid)
return size; return size;
} }
static LPWSTR WINAPI SdbpGetString(PDB db, TAGID tagid, PDWORD size) static LPWSTR WINAPI SdbpGetString(PDB pdb, TAGID tagid, PDWORD size)
{ {
TAG tag; TAG tag;
TAGID offset; TAGID offset;
tag = SdbGetTagFromTagID(db, tagid); tag = SdbGetTagFromTagID(pdb, tagid);
if (tag == TAG_NULL) if (tag == TAG_NULL)
return NULL; return NULL;
if ((tag & TAG_TYPE_MASK) == TAG_TYPE_STRINGREF) if ((tag & TAG_TYPE_MASK) == TAG_TYPE_STRINGREF)
{ {
/* No stringtable; all references are invalid */ /* No stringtable; all references are invalid */
if (db->stringtable == TAGID_NULL) if (pdb->stringtable == TAGID_NULL)
return NULL; return NULL;
/* TAG_TYPE_STRINGREF contains offset of string relative to stringtable */ /* TAG_TYPE_STRINGREF contains offset of string relative to stringtable */
if (!SdbpReadData(db, &tagid, tagid + sizeof(TAG), sizeof(TAGID))) if (!SdbpReadData(pdb, &tagid, tagid + sizeof(TAG), sizeof(TAGID)))
return NULL; return NULL;
offset = db->stringtable + tagid + sizeof(TAG) + sizeof(TAGID); offset = pdb->stringtable + tagid + sizeof(TAG) + sizeof(TAGID);
} }
else if ((tag & TAG_TYPE_MASK) == TAG_TYPE_STRING) else if ((tag & TAG_TYPE_MASK) == TAG_TYPE_STRING)
{ {
@ -90,24 +90,24 @@ static LPWSTR WINAPI SdbpGetString(PDB db, TAGID tagid, PDWORD size)
} }
/* Optionally read string size */ /* Optionally read string size */
if (size && !SdbpReadData(db, size, tagid + sizeof(TAG), sizeof(*size))) if (size && !SdbpReadData(pdb, size, tagid + sizeof(TAG), sizeof(*size)))
return FALSE; return FALSE;
return (LPWSTR)(&db->data[offset]); return (LPWSTR)(&pdb->data[offset]);
} }
/** /**
* Searches shim database for the tag associated with specified tagid. * Searches shim database for the tag associated with specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid The TAGID of the tag. * @param [in] tagid The TAGID of the tag.
* *
* @return Success: The tag associated with specified tagid, Failure: TAG_NULL. * @return Success: The tag associated with specified tagid, Failure: TAG_NULL.
*/ */
TAG WINAPI SdbGetTagFromTagID(PDB db, TAGID tagid) TAG WINAPI SdbGetTagFromTagID(PDB pdb, TAGID tagid)
{ {
TAG data; TAG data;
if (!SdbpReadData(db, &data, tagid, sizeof(data))) if (!SdbpReadData(pdb, &data, tagid, sizeof(data)))
return TAG_NULL; return TAG_NULL;
return data; return data;
} }
@ -115,12 +115,12 @@ TAG WINAPI SdbGetTagFromTagID(PDB db, TAGID tagid)
/** /**
* Retrieves size of data at specified tagid. * Retrieves size of data at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid Tagid of tag whose size is queried. * @param [in] tagid Tagid of tag whose size is queried.
* *
* @return Success: Size of data at specified tagid, Failure: 0. * @return Success: Size of data at specified tagid, Failure: 0.
*/ */
DWORD WINAPI SdbGetTagDataSize(PDB db, TAGID tagid) DWORD WINAPI SdbGetTagDataSize(PDB pdb, TAGID tagid)
{ {
/* sizes of data types with fixed size */ /* sizes of data types with fixed size */
static const SIZE_T sizes[6] = { static const SIZE_T sizes[6] = {
@ -131,7 +131,7 @@ DWORD WINAPI SdbGetTagDataSize(PDB db, TAGID tagid)
WORD type; WORD type;
DWORD size; DWORD size;
type = SdbGetTagFromTagID(db, tagid) & TAG_TYPE_MASK; type = SdbGetTagFromTagID(pdb, tagid) & TAG_TYPE_MASK;
if (type == TAG_NULL) if (type == TAG_NULL)
return 0; return 0;
@ -139,7 +139,7 @@ DWORD WINAPI SdbGetTagDataSize(PDB db, TAGID tagid)
return sizes[(type >> 12) - 1]; return sizes[(type >> 12) - 1];
/* tag with dynamic size (e.g. list): must read size */ /* tag with dynamic size (e.g. list): must read size */
if (!SdbpReadData(db, &size, tagid + sizeof(TAG), sizeof(size))) if (!SdbpReadData(pdb, &size, tagid + sizeof(TAG), sizeof(size)))
return 0; return 0;
return size; return size;
@ -148,25 +148,25 @@ DWORD WINAPI SdbGetTagDataSize(PDB db, TAGID tagid)
/** /**
* Searches shim database for a child of specified parent tag. * Searches shim database for a child of specified parent tag.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] parent TAGID of parent. * @param [in] parent TAGID of parent.
* *
* @return Success: TAGID of child tag, Failure: TAGID_NULL. * @return Success: TAGID of child tag, Failure: TAGID_NULL.
*/ */
TAGID WINAPI SdbGetFirstChild(PDB db, TAGID parent) TAGID WINAPI SdbGetFirstChild(PDB pdb, TAGID parent)
{ {
/* if we are at beginning of database */ /* if we are at beginning of database */
if (parent == TAGID_ROOT) if (parent == TAGID_ROOT)
{ {
/* header only database: no tags */ /* header only database: no tags */
if (db->size <= _TAGID_ROOT) if (pdb->size <= _TAGID_ROOT)
return TAGID_NULL; return TAGID_NULL;
/* return *real* root tagid */ /* return *real* root tagid */
else return _TAGID_ROOT; else return _TAGID_ROOT;
} }
/* only list tag can have children */ /* only list tag can have children */
if ((SdbGetTagFromTagID(db, parent) & TAG_TYPE_MASK) != TAG_TYPE_LIST) if ((SdbGetTagFromTagID(pdb, parent) & TAG_TYPE_MASK) != TAG_TYPE_LIST)
return TAGID_NULL; return TAGID_NULL;
/* first child is sizeof(TAG) + sizeof(DWORD) bytes after beginning of list */ /* first child is sizeof(TAG) + sizeof(DWORD) bytes after beginning of list */
@ -176,30 +176,30 @@ TAGID WINAPI SdbGetFirstChild(PDB db, TAGID parent)
/** /**
* Searches shim database for next child of specified parent tag. * Searches shim database for next child of specified parent tag.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] parent TAGID of parent. * @param [in] parent TAGID of parent.
* @param [in] prev_child TAGID of previous child. * @param [in] prev_child TAGID of previous child.
* *
* @return Success: TAGID of next child tag, Failure: TAGID_NULL. * @return Success: TAGID of next child tag, Failure: TAGID_NULL.
*/ */
TAGID WINAPI SdbGetNextChild(PDB db, TAGID parent, TAGID prev_child) TAGID WINAPI SdbGetNextChild(PDB pdb, TAGID parent, TAGID prev_child)
{ {
TAGID next_child; TAGID next_child;
DWORD prev_child_size, parent_size; DWORD prev_child_size, parent_size;
prev_child_size = SdbpGetTagSize(db, prev_child); prev_child_size = SdbpGetTagSize(pdb, prev_child);
if (prev_child_size == 0) if (prev_child_size == 0)
return TAGID_NULL; return TAGID_NULL;
/* Bound check */ /* Bound check */
next_child = prev_child + prev_child_size; next_child = prev_child + prev_child_size;
if (next_child >= db->size) if (next_child >= pdb->size)
return TAGID_NULL; return TAGID_NULL;
if (parent == TAGID_ROOT) if (parent == TAGID_ROOT)
return next_child; return next_child;
parent_size = SdbpGetTagSize(db, parent); parent_size = SdbpGetTagSize(pdb, parent);
if (parent_size == 0) if (parent_size == 0)
return TAGID_NULL; return TAGID_NULL;
@ -213,22 +213,22 @@ TAGID WINAPI SdbGetNextChild(PDB db, TAGID parent, TAGID prev_child)
/** /**
* Searches shim database for a tag within specified domain. * Searches shim database for a tag within specified domain.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] parent TAGID of parent. * @param [in] parent TAGID of parent.
* @param [in] tag TAG to be located. * @param [in] tag TAG to be located.
* *
* @return Success: TAGID of first matching tag, Failure: TAGID_NULL. * @return Success: TAGID of first matching tag, Failure: TAGID_NULL.
*/ */
TAGID WINAPI SdbFindFirstTag(PDB db, TAGID parent, TAG tag) TAGID WINAPI SdbFindFirstTag(PDB pdb, TAGID parent, TAG tag)
{ {
TAGID iter; TAGID iter;
iter = SdbGetFirstChild(db, parent); iter = SdbGetFirstChild(pdb, parent);
while (iter != TAGID_NULL) while (iter != TAGID_NULL)
{ {
if (SdbGetTagFromTagID(db, iter) == tag) if (SdbGetTagFromTagID(pdb, iter) == tag)
return iter; return iter;
iter = SdbGetNextChild(db, parent, iter); iter = SdbGetNextChild(pdb, parent, iter);
} }
return TAGID_NULL; return TAGID_NULL;
} }
@ -236,25 +236,25 @@ TAGID WINAPI SdbFindFirstTag(PDB db, TAGID parent, TAG tag)
/** /**
* Searches shim database for a next tag which matches prev_child within parent's domain. * Searches shim database for a next tag which matches prev_child within parent's domain.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] parent TAGID of parent. * @param [in] parent TAGID of parent.
* @param [in] prev_child TAGID of previous match. * @param [in] prev_child TAGID of previous match.
* *
* @return Success: TAGID of next match, Failure: TAGID_NULL. * @return Success: TAGID of next match, Failure: TAGID_NULL.
*/ */
TAGID WINAPI SdbFindNextTag(PDB db, TAGID parent, TAGID prev_child) TAGID WINAPI SdbFindNextTag(PDB pdb, TAGID parent, TAGID prev_child)
{ {
TAG tag; TAG tag;
TAGID iter; TAGID iter;
tag = SdbGetTagFromTagID(db, prev_child); tag = SdbGetTagFromTagID(pdb, prev_child);
iter = SdbGetNextChild(db, parent, prev_child); iter = SdbGetNextChild(pdb, parent, prev_child);
while (iter != TAGID_NULL) while (iter != TAGID_NULL)
{ {
if (SdbGetTagFromTagID(db, iter) == tag) if (SdbGetTagFromTagID(pdb, iter) == tag)
return iter; return iter;
iter = SdbGetNextChild(db, parent, iter); iter = SdbGetNextChild(pdb, parent, iter);
} }
return TAGID_NULL; return TAGID_NULL;
} }
@ -266,7 +266,7 @@ TAGID WINAPI SdbFindNextTag(PDB db, TAGID parent, TAGID prev_child)
* If size parameter is less than number of characters in string, this function shall fail and * If size parameter is less than number of characters in string, this function shall fail and
* no data shall be copied. * no data shall be copied.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of string or stringref associated with the string. * @param [in] tagid TAGID of string or stringref associated with the string.
* @param [out] buffer Buffer in which string will be copied. * @param [out] buffer Buffer in which string will be copied.
* @param [in] size Number of characters to copy. * @param [in] size Number of characters to copy.
@ -274,12 +274,12 @@ TAGID WINAPI SdbFindNextTag(PDB db, TAGID parent, TAGID prev_child)
* @return TRUE if string was successfully copied to the buffer FALSE if string was not copied * @return TRUE if string was successfully copied to the buffer FALSE if string was not copied
* to the buffer. * to the buffer.
*/ */
BOOL WINAPI SdbReadStringTag(PDB db, TAGID tagid, LPWSTR buffer, DWORD size) BOOL WINAPI SdbReadStringTag(PDB pdb, TAGID tagid, LPWSTR buffer, DWORD size)
{ {
LPWSTR string; LPWSTR string;
DWORD string_size; DWORD string_size;
string = SdbpGetString(db, tagid, &string_size); string = SdbpGetString(pdb, tagid, &string_size);
if (!string) if (!string)
return FALSE; return FALSE;
@ -294,70 +294,70 @@ BOOL WINAPI SdbReadStringTag(PDB db, TAGID tagid, LPWSTR buffer, DWORD size)
/** /**
* Reads WORD value at specified tagid. * Reads WORD value at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of WORD value. * @param [in] tagid TAGID of WORD value.
* @param [in] ret Default return value in case function fails. * @param [in] ret Default return value in case function fails.
* *
* @return Success: WORD value at specified tagid, or ret on failure. * @return Success: WORD value at specified tagid, or ret on failure.
*/ */
WORD WINAPI SdbReadWORDTag(PDB db, TAGID tagid, WORD ret) WORD WINAPI SdbReadWORDTag(PDB pdb, TAGID tagid, WORD ret)
{ {
if (SdbpCheckTagIDType(db, tagid, TAG_TYPE_WORD)) if (SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_WORD))
SdbpReadData(db, &ret, tagid + 2, sizeof(WORD)); SdbpReadData(pdb, &ret, tagid + 2, sizeof(WORD));
return ret; return ret;
} }
/** /**
* Reads DWORD value at specified tagid. * Reads DWORD value at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of DWORD value. * @param [in] tagid TAGID of DWORD value.
* @param [in] ret Default return value in case function fails. * @param [in] ret Default return value in case function fails.
* *
* @return Success: DWORD value at specified tagid, otherwise ret. * @return Success: DWORD value at specified tagid, otherwise ret.
*/ */
DWORD WINAPI SdbReadDWORDTag(PDB db, TAGID tagid, DWORD ret) DWORD WINAPI SdbReadDWORDTag(PDB pdb, TAGID tagid, DWORD ret)
{ {
if (SdbpCheckTagIDType(db, tagid, TAG_TYPE_DWORD)) if (SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_DWORD))
SdbpReadData(db, &ret, tagid + 2, sizeof(DWORD)); SdbpReadData(pdb, &ret, tagid + 2, sizeof(DWORD));
return ret; return ret;
} }
/** /**
* Reads QWORD value at specified tagid. * Reads QWORD value at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of QWORD value. * @param [in] tagid TAGID of QWORD value.
* @param [in] ret Default return value in case function fails. * @param [in] ret Default return value in case function fails.
* *
* @return Success: QWORD value at specified tagid, otherwise ret. * @return Success: QWORD value at specified tagid, otherwise ret.
*/ */
QWORD WINAPI SdbReadQWORDTag(PDB db, TAGID tagid, QWORD ret) QWORD WINAPI SdbReadQWORDTag(PDB pdb, TAGID tagid, QWORD ret)
{ {
if (SdbpCheckTagIDType(db, tagid, TAG_TYPE_QWORD)) if (SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_QWORD))
SdbpReadData(db, &ret, tagid + sizeof(TAG), sizeof(QWORD)); SdbpReadData(pdb, &ret, tagid + sizeof(TAG), sizeof(QWORD));
return ret; return ret;
} }
/** /**
* Reads binary data at specified tagid. * Reads binary data at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of binary data. * @param [in] tagid TAGID of binary data.
* @param [out] buffer Buffer in which data will be copied. * @param [out] buffer Buffer in which data will be copied.
* @param [in] size Size of the buffer. * @param [in] size Size of the buffer.
* *
* @return TRUE if data was successfully written, or FALSE otherwise. * @return TRUE if data was successfully written, or FALSE otherwise.
*/ */
BOOL WINAPI SdbReadBinaryTag(PDB db, TAGID tagid, PBYTE buffer, DWORD size) BOOL WINAPI SdbReadBinaryTag(PDB pdb, TAGID tagid, PBYTE buffer, DWORD size)
{ {
DWORD data_size = 0; DWORD data_size = 0;
if (SdbpCheckTagIDType(db, tagid, TAG_TYPE_BINARY)) if (SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_BINARY))
{ {
SdbpReadData(db, &data_size, tagid + sizeof(TAG), sizeof(data_size)); SdbpReadData(pdb, &data_size, tagid + sizeof(TAG), sizeof(data_size));
if (size >= data_size) if (size >= data_size)
return SdbpReadData(db, buffer, tagid + sizeof(TAG) + sizeof(data_size), data_size); return SdbpReadData(pdb, buffer, tagid + sizeof(TAG) + sizeof(data_size), data_size);
} }
return FALSE; return FALSE;
@ -366,52 +366,52 @@ BOOL WINAPI SdbReadBinaryTag(PDB db, TAGID tagid, PBYTE buffer, DWORD size)
/** /**
* Retrieves binary data at specified tagid. * Retrieves binary data at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of binary data. * @param [in] tagid TAGID of binary data.
* *
* @return Success: Pointer to binary data at specified tagid, or NULL on failure. * @return Success: Pointer to binary data at specified tagid, or NULL on failure.
*/ */
PVOID WINAPI SdbGetBinaryTagData(PDB db, TAGID tagid) PVOID WINAPI SdbGetBinaryTagData(PDB pdb, TAGID tagid)
{ {
if (!SdbpCheckTagIDType(db, tagid, TAG_TYPE_BINARY)) if (!SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_BINARY))
return NULL; return NULL;
return &db->data[tagid + sizeof(TAG) + sizeof(DWORD)]; return &pdb->data[tagid + sizeof(TAG) + sizeof(DWORD)];
} }
/** /**
* Searches shim database for string associated with specified tagid. * Searches shim database for string associated with specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of string or stringref associated with the string. * @param [in] tagid TAGID of string or stringref associated with the string.
* *
* @return the LPWSTR associated with specified tagid, or NULL on failure. * @return the LPWSTR associated with specified tagid, or NULL on failure.
*/ */
LPWSTR WINAPI SdbGetStringTagPtr(PDB db, TAGID tagid) LPWSTR WINAPI SdbGetStringTagPtr(PDB pdb, TAGID tagid)
{ {
return SdbpGetString(db, tagid, NULL); return SdbpGetString(pdb, tagid, NULL);
} }
/** /**
* Reads binary data at specified tagid. * Reads binary data at specified tagid.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [out] Guid Database ID. * @param [out] Guid Database ID.
* *
* @return true if the ID was found FALSE otherwise. * @return true if the ID was found FALSE otherwise.
*/ */
BOOL WINAPI SdbGetDatabaseID(PDB db, GUID* Guid) BOOL WINAPI SdbGetDatabaseID(PDB pdb, GUID* Guid)
{ {
if(SdbIsNullGUID(&db->database_id)) if(SdbIsNullGUID(&pdb->database_id))
{ {
TAGID root = SdbFindFirstTag(db, TAGID_ROOT, TAG_DATABASE); TAGID root = SdbFindFirstTag(pdb, TAGID_ROOT, TAG_DATABASE);
if(root != TAGID_NULL) if(root != TAGID_NULL)
{ {
TAGID id = SdbFindFirstTag(db, root, TAG_DATABASE_ID); TAGID id = SdbFindFirstTag(pdb, root, TAG_DATABASE_ID);
if(id != TAGID_NULL) if(id != TAGID_NULL)
{ {
if(!SdbReadBinaryTag(db, id, (PBYTE)&db->database_id, sizeof(db->database_id))) if(!SdbReadBinaryTag(pdb, id, (PBYTE)&pdb->database_id, sizeof(pdb->database_id)))
{ {
memset(&db->database_id, 0, sizeof(db->database_id)); memset(&pdb->database_id, 0, sizeof(pdb->database_id));
} }
} }
else else
@ -426,9 +426,9 @@ BOOL WINAPI SdbGetDatabaseID(PDB db, GUID* Guid)
SHIM_ERR("Failed to get root tag\n"); SHIM_ERR("Failed to get root tag\n");
} }
} }
if(!SdbIsNullGUID(&db->database_id)) if(!SdbIsNullGUID(&pdb->database_id))
{ {
memcpy(Guid, &db->database_id, sizeof(db->database_id)); memcpy(Guid, &pdb->database_id, sizeof(pdb->database_id));
return TRUE; return TRUE;
} }
return FALSE; return FALSE;

3
reactos/dll/appcompat/apphelp/sdbtypes.h
View file

@ -1,6 +1,6 @@
/* /*
* Copyright 2013 Mislav Blažević * Copyright 2013 Mislav Blažević
* Copyright 2015,2016 Mark Jansen * Copyright 2015-2017 Mark Jansen (mark.jansen@reactos.org)
* *
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
@ -39,6 +39,7 @@ typedef struct _DB {
TAGID stringtable; TAGID stringtable;
DWORD write_iter; DWORD write_iter;
GUID database_id; GUID database_id;
BOOL for_write;
struct SdbStringHashTable* string_lookup; struct SdbStringHashTable* string_lookup;
struct _DB* string_buffer; struct _DB* string_buffer;
} DB, *PDB; } DB, *PDB;

172
reactos/dll/appcompat/apphelp/sdbwrite.c
View file

@ -34,60 +34,67 @@
/* Local functions */ /* Local functions */
BOOL WINAPI SdbWriteStringRefTag(PDB db, TAG tag, TAGID tagid); BOOL WINAPI SdbWriteStringRefTag(PDB pdb, TAG tag, TAGID tagid);
BOOL WINAPI SdbWriteStringTag(PDB db, TAG tag, LPCWSTR string); BOOL WINAPI SdbWriteStringTag(PDB pdb, TAG tag, LPCWSTR string);
TAGID WINAPI SdbBeginWriteListTag(PDB db, TAG tag); TAGID WINAPI SdbBeginWriteListTag(PDB pdb, TAG tag);
BOOL WINAPI SdbEndWriteListTag(PDB db, TAGID tagid); BOOL WINAPI SdbEndWriteListTag(PDB pdb, TAGID tagid);
/* sdbapi.c */ /* sdbapi.c */
void WINAPI SdbCloseDatabase(PDB); void WINAPI SdbCloseDatabase(PDB);
/* Copy data to the allocated database */
static void WINAPI SdbpWrite(PDB db, const void* data, DWORD size) static void WINAPI SdbpWrite(PDB pdb, const void* data, DWORD size)
{ {
if (db->write_iter + size > db->size) ASSERT(pdb->for_write);
if (pdb->write_iter + size > pdb->size)
{ {
DWORD oldSize = db->size; DWORD oldSize = pdb->size;
/* Round to powers of two to prevent too many reallocations */ /* Round to powers of two to prevent too many reallocations */
while (db->size < db->write_iter + size) db->size <<= 1; while (pdb->size < pdb->write_iter + size) pdb->size <<= 1;
db->data = SdbReAlloc(db->data, db->size, oldSize); pdb->data = SdbReAlloc(pdb->data, pdb->size, oldSize);
} }
memcpy(db->data + db->write_iter, data, size); memcpy(pdb->data + pdb->write_iter, data, size);
db->write_iter += size; pdb->write_iter += size;
} }
static BOOL WINAPI SdbpGetOrAddStringRef(PDB db, LPCWSTR string, TAGID* tagid) /* Add a string to the string table (creating it when it did not exist yet),
returning if it succeeded or not */
static BOOL WINAPI SdbpGetOrAddStringRef(PDB pdb, LPCWSTR string, TAGID* tagid)
{ {
PDB buf = db->string_buffer; PDB buf = pdb->string_buffer;
if (db->string_buffer == NULL) ASSERT(pdb->for_write);
if (pdb->string_buffer == NULL)
{ {
db->string_buffer = buf = SdbAlloc(sizeof(DB)); pdb->string_buffer = buf = SdbAlloc(sizeof(DB));
if (buf == NULL) if (buf == NULL)
return FALSE; return FALSE;
buf->size = 128; buf->size = 128;
buf->data = SdbAlloc(buf->size); buf->data = SdbAlloc(buf->size);
buf->for_write = TRUE;
if (buf->data == NULL) if (buf->data == NULL)
return FALSE; return FALSE;
} }
*tagid = buf->write_iter + sizeof(TAG) + sizeof(DWORD); *tagid = buf->write_iter + sizeof(TAG) + sizeof(DWORD);
if (SdbpAddStringToTable(&db->string_lookup, string, tagid)) if (SdbpAddStringToTable(&pdb->string_lookup, string, tagid))
return SdbWriteStringTag(buf, TAG_STRINGTABLE_ITEM, string); return SdbWriteStringTag(buf, TAG_STRINGTABLE_ITEM, string);
return db->string_lookup != NULL; return pdb->string_lookup != NULL;
} }
static BOOL WINAPI SdbpWriteStringtable(PDB db) /* Write the in-memory stringtable to the specified db */
static BOOL WINAPI SdbpWriteStringtable(PDB pdb)
{ {
TAGID table; TAGID table;
PDB buf = db->string_buffer; PDB buf = pdb->string_buffer;
if (buf == NULL || db->string_lookup == NULL) if (buf == NULL || pdb->string_lookup == NULL)
return FALSE; return FALSE;
table = SdbBeginWriteListTag(db, TAG_STRINGTABLE); table = SdbBeginWriteListTag(pdb, TAG_STRINGTABLE);
SdbpWrite(db, buf->data, buf->write_iter); SdbpWrite(pdb, buf->data, buf->write_iter);
return SdbEndWriteListTag(db, table); return SdbEndWriteListTag(pdb, table);
} }
/** /**
@ -106,137 +113,138 @@ PDB WINAPI SdbCreateDatabase(LPCWSTR path, PATH_TYPE type)
{ {
static const DWORD version_major = 2, version_minor = 1; static const DWORD version_major = 2, version_minor = 1;
static const char* magic = "sdbf"; static const char* magic = "sdbf";
PDB db; PDB pdb;
db = SdbpCreate(path, type, TRUE); pdb = SdbpCreate(path, type, TRUE);
if (!db) if (!pdb)
return NULL; return NULL;
db->size = sizeof(DWORD) + sizeof(DWORD) + strlen(magic); pdb->size = sizeof(DWORD) + sizeof(DWORD) + strlen(magic);
db->data = SdbAlloc(db->size); pdb->data = SdbAlloc(pdb->size);
SdbpWrite(db, &version_major, sizeof(DWORD)); SdbpWrite(pdb, &version_major, sizeof(DWORD));
SdbpWrite(db, &version_minor, sizeof(DWORD)); SdbpWrite(pdb, &version_minor, sizeof(DWORD));
SdbpWrite(db, magic, strlen(magic)); SdbpWrite(pdb, magic, strlen(magic));
return db; return pdb;
} }
/** /**
* Closes specified database and writes data to file. * Closes specified database and writes data to file.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
*/ */
void WINAPI SdbCloseDatabaseWrite(PDB db) void WINAPI SdbCloseDatabaseWrite(PDB pdb)
{ {
SdbpWriteStringtable(db); ASSERT(pdb->for_write);
SdbpFlush(db); SdbpWriteStringtable(pdb);
SdbCloseDatabase(db); SdbpFlush(pdb);
SdbCloseDatabase(pdb);
} }
/** /**
* Writes a tag-only (NULL) entry to the specified shim database. * Writes a tag-only (NULL) entry to the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteNULLTag(PDB db, TAG tag) BOOL WINAPI SdbWriteNULLTag(PDB pdb, TAG tag)
{ {
if (!SdbpCheckTagType(tag, TAG_TYPE_NULL)) if (!SdbpCheckTagType(tag, TAG_TYPE_NULL))
return FALSE; return FALSE;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
return TRUE; return TRUE;
} }
/** /**
* Writes a WORD entry to the specified shim database. * Writes a WORD entry to the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* @param [in] data WORD entry which will be written to the database. * @param [in] data WORD entry which will be written to the database.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteWORDTag(PDB db, TAG tag, WORD data) BOOL WINAPI SdbWriteWORDTag(PDB pdb, TAG tag, WORD data)
{ {
if (!SdbpCheckTagType(tag, TAG_TYPE_WORD)) if (!SdbpCheckTagType(tag, TAG_TYPE_WORD))
return FALSE; return FALSE;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &data, sizeof(data)); SdbpWrite(pdb, &data, sizeof(data));
return TRUE; return TRUE;
} }
/** /**
* Writes a DWORD entry to the specified shim database. * Writes a DWORD entry to the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* @param [in] data DWORD entry which will be written to the database. * @param [in] data DWORD entry which will be written to the database.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteDWORDTag(PDB db, TAG tag, DWORD data) BOOL WINAPI SdbWriteDWORDTag(PDB pdb, TAG tag, DWORD data)
{ {
if (!SdbpCheckTagType(tag, TAG_TYPE_DWORD)) if (!SdbpCheckTagType(tag, TAG_TYPE_DWORD))
return FALSE; return FALSE;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &data, sizeof(data)); SdbpWrite(pdb, &data, sizeof(data));
return TRUE; return TRUE;
} }
/** /**
* Writes a DWORD entry to the specified shim database. * Writes a DWORD entry to the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* @param [in] data QWORD entry which will be written to the database. * @param [in] data QWORD entry which will be written to the database.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteQWORDTag(PDB db, TAG tag, QWORD data) BOOL WINAPI SdbWriteQWORDTag(PDB pdb, TAG tag, QWORD data)
{ {
if (!SdbpCheckTagType(tag, TAG_TYPE_QWORD)) if (!SdbpCheckTagType(tag, TAG_TYPE_QWORD))
return FALSE; return FALSE;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &data, sizeof(data)); SdbpWrite(pdb, &data, sizeof(data));
return TRUE; return TRUE;
} }
/** /**
* Writes a wide string entry to the specified shim database. * Writes a wide string entry to the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* @param [in] string Wide string entry which will be written to the database. * @param [in] string Wide string entry which will be written to the database.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteStringTag(PDB db, TAG tag, LPCWSTR string) BOOL WINAPI SdbWriteStringTag(PDB pdb, TAG tag, LPCWSTR string)
{ {
DWORD size; DWORD size;
if (SdbpCheckTagType(tag, TAG_TYPE_STRINGREF)) if (SdbpCheckTagType(tag, TAG_TYPE_STRINGREF))
{ {
TAGID tagid = 0; TAGID tagid = 0;
if (!SdbpGetOrAddStringRef(db, string, &tagid)) if (!SdbpGetOrAddStringRef(pdb, string, &tagid))
return FALSE; return FALSE;
return SdbWriteStringRefTag(db, tag, tagid); return SdbWriteStringRefTag(pdb, tag, tagid);
} }
if (!SdbpCheckTagType(tag, TAG_TYPE_STRING)) if (!SdbpCheckTagType(tag, TAG_TYPE_STRING))
return FALSE; return FALSE;
size = SdbpStrsize(string); size = SdbpStrsize(string);
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &size, sizeof(size)); SdbpWrite(pdb, &size, sizeof(size));
SdbpWrite(db, string, size); SdbpWrite(pdb, string, size);
return TRUE; return TRUE;
} }
@ -244,40 +252,40 @@ BOOL WINAPI SdbWriteStringTag(PDB db, TAG tag, LPCWSTR string)
* Writes a stringref tag to specified database * Writes a stringref tag to specified database
* @note Reference (tagid) is not checked for validity. * @note Reference (tagid) is not checked for validity.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag TAG which will be written. * @param [in] tag TAG which will be written.
* @param [in] tagid TAGID of the string tag refers to. * @param [in] tagid TAGID of the string tag refers to.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteStringRefTag(PDB db, TAG tag, TAGID tagid) BOOL WINAPI SdbWriteStringRefTag(PDB pdb, TAG tag, TAGID tagid)
{ {
if (!SdbpCheckTagType(tag, TAG_TYPE_STRINGREF)) if (!SdbpCheckTagType(tag, TAG_TYPE_STRINGREF))
return FALSE; return FALSE;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &tagid, sizeof(tagid)); SdbpWrite(pdb, &tagid, sizeof(tagid));
return TRUE; return TRUE;
} }
/** /**
* Writes data the specified shim database. * Writes data the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* @param [in] data Pointer to data. * @param [in] data Pointer to data.
* @param [in] size Number of bytes to write. * @param [in] size Number of bytes to write.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteBinaryTag(PDB db, TAG tag, const BYTE* data, DWORD size) BOOL WINAPI SdbWriteBinaryTag(PDB pdb, TAG tag, const BYTE* data, DWORD size)
{ {
if (!SdbpCheckTagType(tag, TAG_TYPE_BINARY)) if (!SdbpCheckTagType(tag, TAG_TYPE_BINARY))
return FALSE; return FALSE;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &size, sizeof(size)); SdbpWrite(pdb, &size, sizeof(size));
SdbpWrite(db, data, size); SdbpWrite(pdb, data, size);
return TRUE; return TRUE;
} }
@ -285,13 +293,13 @@ BOOL WINAPI SdbWriteBinaryTag(PDB db, TAG tag, const BYTE* data, DWORD size)
/** /**
* Writes data from a file to the specified shim database. * Writes data from a file to the specified shim database.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag A tag for the entry. * @param [in] tag A tag for the entry.
* @param [in] path Path of the input file. * @param [in] path Path of the input file.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbWriteBinaryTagFromFile(PDB db, TAG tag, LPCWSTR path) BOOL WINAPI SdbWriteBinaryTagFromFile(PDB pdb, TAG tag, LPCWSTR path)
{ {
MEMMAPPED mapped; MEMMAPPED mapped;
@ -301,7 +309,7 @@ BOOL WINAPI SdbWriteBinaryTagFromFile(PDB db, TAG tag, LPCWSTR path)
if (!SdbpOpenMemMappedFile(path, &mapped)) if (!SdbpOpenMemMappedFile(path, &mapped))
return FALSE; return FALSE;
SdbWriteBinaryTag(db, tag, mapped.view, mapped.size); SdbWriteBinaryTag(pdb, tag, mapped.view, mapped.size);
SdbpCloseMemMappedFile(&mapped); SdbpCloseMemMappedFile(&mapped);
return TRUE; return TRUE;
} }
@ -311,14 +319,14 @@ BOOL WINAPI SdbWriteBinaryTagFromFile(PDB db, TAG tag, LPCWSTR path)
* Writes a list tag to specified database All subsequent SdbWrite* functions shall write to * Writes a list tag to specified database All subsequent SdbWrite* functions shall write to
* newly created list untill TAGID of that list is passed to SdbEndWriteListTag. * newly created list untill TAGID of that list is passed to SdbEndWriteListTag.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tag TAG for the list * @param [in] tag TAG for the list
* *
* RETURNS Success: TAGID of the newly created list, or TAGID_NULL on failure. * RETURNS Success: TAGID of the newly created list, or TAGID_NULL on failure.
* *
* @return A TAGID. * @return A TAGID.
*/ */
TAGID WINAPI SdbBeginWriteListTag(PDB db, TAG tag) TAGID WINAPI SdbBeginWriteListTag(PDB pdb, TAG tag)
{ {
TAGID list_id; TAGID list_id;
DWORD dum = 0; DWORD dum = 0;
@ -326,27 +334,29 @@ TAGID WINAPI SdbBeginWriteListTag(PDB db, TAG tag)
if (!SdbpCheckTagType(tag, TAG_TYPE_LIST)) if (!SdbpCheckTagType(tag, TAG_TYPE_LIST))
return TAGID_NULL; return TAGID_NULL;
list_id = db->write_iter; list_id = pdb->write_iter;
SdbpWrite(db, &tag, sizeof(TAG)); SdbpWrite(pdb, &tag, sizeof(TAG));
SdbpWrite(db, &dum, sizeof(dum)); /* reserve some memory for storing list size */ SdbpWrite(pdb, &dum, sizeof(dum)); /* reserve some memory for storing list size */
return list_id; return list_id;
} }
/** /**
* Marks end of the specified list. * Marks end of the specified list.
* *
* @param [in] db Handle to the shim database. * @param [in] pdb Handle to the shim database.
* @param [in] tagid TAGID of the list. * @param [in] tagid TAGID of the list.
* *
* @return TRUE if it succeeds, FALSE if it fails. * @return TRUE if it succeeds, FALSE if it fails.
*/ */
BOOL WINAPI SdbEndWriteListTag(PDB db, TAGID tagid) BOOL WINAPI SdbEndWriteListTag(PDB pdb, TAGID tagid)
{ {
if (!SdbpCheckTagIDType(db, tagid, TAG_TYPE_LIST)) ASSERT(pdb->for_write);
if (!SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_LIST))
return FALSE; return FALSE;
/* Write size of list to list tag header */ /* Write size of list to list tag header */
*(DWORD*)&db->data[tagid + sizeof(TAG)] = db->write_iter - tagid - sizeof(TAG) - sizeof(TAGID); *(DWORD*)&pdb->data[tagid + sizeof(TAG)] = pdb->write_iter - tagid - sizeof(TAG) - sizeof(TAGID);
return TRUE; return TRUE;
} }

3
reactos/dll/appcompat/shims/genral/themes.c
View file

@ -3,7 +3,7 @@
* PROJECT: ReactOS Shim library * PROJECT: ReactOS Shim library
* FILE: dll/appcompat/shims/genral/themes.c * FILE: dll/appcompat/shims/genral/themes.c
* PURPOSE: Theme related shims * PURPOSE: Theme related shims
* PROGRAMMER: Mark Jansen * PROGRAMMER: Mark Jansen (mark.jansen@reactos.org)
*/ */
#include <windows.h> #include <windows.h>
@ -22,6 +22,7 @@ BOOL WINAPI SHIM_OBJ_NAME(Notify)(DWORD fdwReason, PVOID ptr)
{ {
if (fdwReason == SHIM_REASON_INIT) if (fdwReason == SHIM_REASON_INIT)
{ {
/* Disable themes for non-client, comctl controls and webcontent */
SetThemeAppProperties(0); SetThemeAppProperties(0);
} }
return TRUE; return TRUE;

49
reactos/sdk/tools/xml2sdb/main.cpp
View file

@ -53,7 +53,7 @@ DWORD WINAPI SdbpStrsize(PCWSTR string)
PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write) PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write)
{ {
PDB db; PDB pdb;
FILE* f; FILE* f;
std::string pathA(path, path + SdbpStrlen(path)); std::string pathA(path, path + SdbpStrlen(path));
@ -61,30 +61,33 @@ PDB WINAPI SdbpCreate(LPCWSTR path, PATH_TYPE type, BOOL write)
if (!f) if (!f)
return NULL; return NULL;
db = (PDB)SdbAlloc(sizeof(DB)); pdb = (PDB)SdbAlloc(sizeof(DB));
db->file = f; pdb->file = f;
pdb->for_write = write;
return db; return pdb;
} }
void WINAPI SdbpFlush(PDB db) void WINAPI SdbpFlush(PDB pdb)
{ {
fwrite(db->data, db->write_iter, 1, (FILE*)db->file); ASSERT(pdb->for_write);
fwrite(pdb->data, pdb->write_iter, 1, (FILE*)pdb->file);
} }
void WINAPI SdbCloseDatabase(PDB db) void WINAPI SdbCloseDatabase(PDB pdb)
{ {
if (!db) if (!pdb)
return; return;
if (db->file) if (pdb->file)
fclose((FILE*)db->file); fclose((FILE*)pdb->file);
if (db->string_buffer) if (pdb->string_buffer)
SdbCloseDatabase(db->string_buffer); SdbCloseDatabase(pdb->string_buffer);
if (db->string_lookup) if (pdb->string_lookup)
SdbpTableDestroy(&db->string_lookup); SdbpTableDestroy(&pdb->string_lookup);
SdbFree(db->data); SdbFree(pdb->data);
SdbFree(db); SdbFree(pdb);
} }
BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type) BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type)
@ -94,7 +97,7 @@ BOOL WINAPI SdbpCheckTagType(TAG tag, WORD type)
return TRUE; return TRUE;
} }
BOOL WINAPI SdbpReadData(PDB db, PVOID dest, DWORD offset, DWORD num) BOOL WINAPI SdbpReadData(PDB pdb, PVOID dest, DWORD offset, DWORD num)
{ {
DWORD size = offset + num; DWORD size = offset + num;
@ -103,24 +106,24 @@ BOOL WINAPI SdbpReadData(PDB db, PVOID dest, DWORD offset, DWORD num)
return FALSE; return FALSE;
/* Overflow */ /* Overflow */
if (db->size < size) if (pdb->size < size)
return FALSE; return FALSE;
memcpy(dest, db->data + offset, num); memcpy(dest, pdb->data + offset, num);
return TRUE; return TRUE;
} }
TAG WINAPI SdbGetTagFromTagID(PDB db, TAGID tagid) TAG WINAPI SdbGetTagFromTagID(PDB pdb, TAGID tagid)
{ {
TAG data; TAG data;
if (!SdbpReadData(db, &data, tagid, sizeof(data))) if (!SdbpReadData(pdb, &data, tagid, sizeof(data)))
return TAG_NULL; return TAG_NULL;
return data; return data;
} }
BOOL WINAPI SdbpCheckTagIDType(PDB db, TAGID tagid, WORD type) BOOL WINAPI SdbpCheckTagIDType(PDB pdb, TAGID tagid, WORD type)
{ {
TAG tag = SdbGetTagFromTagID(db, tagid); TAG tag = SdbGetTagFromTagID(pdb, tagid);
if (tag == TAG_NULL) if (tag == TAG_NULL)
return FALSE; return FALSE;
return SdbpCheckTagType(tag, type); return SdbpCheckTagType(tag, type);

8
reactos/sdk/tools/xml2sdb/xml2sdb.cpp
View file

@ -491,14 +491,14 @@ void Database::WriteDWord(PDB pdb, TAG tag, DWORD value, bool always)
SdbWriteDWORDTag(pdb, tag, value); SdbWriteDWORDTag(pdb, tag, value);
} }
TAGID Database::BeginWriteListTag(PDB db, TAG tag) TAGID Database::BeginWriteListTag(PDB pdb, TAG tag)
{ {
return SdbBeginWriteListTag(db, tag); return SdbBeginWriteListTag(pdb, tag);
} }
BOOL Database::EndWriteListTag(PDB db, TAGID tagid) BOOL Database::EndWriteListTag(PDB pdb, TAGID tagid)
{ {
return SdbEndWriteListTag(db, tagid); return SdbEndWriteListTag(pdb, tagid);
} }
bool Database::fromXml(XMLHandle dbNode) bool Database::fromXml(XMLHandle dbNode)

4
reactos/sdk/tools/xml2sdb/xml2sdb.h
View file

@ -128,8 +128,8 @@ struct Database
void WriteBinary(PDB pdb, TAG tag, const GUID& guid, bool always = false); void WriteBinary(PDB pdb, TAG tag, const GUID& guid, bool always = false);
void WriteBinary(PDB pdb, TAG tag, const std::vector<BYTE>& data, bool always = false); void WriteBinary(PDB pdb, TAG tag, const std::vector<BYTE>& data, bool always = false);
void WriteDWord(PDB pdb, TAG tag, DWORD value, bool always = false); void WriteDWord(PDB pdb, TAG tag, DWORD value, bool always = false);
TAGID BeginWriteListTag(PDB db, TAG tag); TAGID BeginWriteListTag(PDB pdb, TAG tag);
BOOL EndWriteListTag(PDB db, TAGID tagid); BOOL EndWriteListTag(PDB pdb, TAGID tagid);
void InsertShimTagid(const sdbstring& name, TAGID tagid); void InsertShimTagid(const sdbstring& name, TAGID tagid);
inline void InsertShimTagid(const std::string& name, TAGID tagid) inline void InsertShimTagid(const std::string& name, TAGID tagid)