sdbwrite.c

Go to the documentation of this file.

/*
 * PROJECT:     ReactOS Application compatibility module
 * LICENSE:     GPL-2.0-or-later (https://spdx.org/licenses/GPL-2.0-or-later)
 * PURPOSE:     Shim database manipulation functions
 * COPYRIGHT:   Copyright 2011 André Hentschel
 *              Copyright 2013 Mislav Blažević
 *              Copyright 2015-2019 Mark Jansen (mark.jansen@reactos.org)
 */
 
#if !defined(SDBWRITE_HOSTTOOL)
#define WIN32_NO_STATUS
#include "windef.h"
#include "ntndk.h"
#include <appcompat/sdbtypes.h>
#include <appcompat/sdbtagid.h>
#else
#include <typedefs.h>
#include <guiddef.h>
#include <sdbtypes.h>
#include <sdbtagid.h>
#endif
 
 
#include "sdbpapi.h"
#include "sdbstringtable.h"
 
 
/* Local functions */
BOOL WINAPI SdbWriteStringRefTag(PDB pdb, TAG tag, TAGID tagid);
BOOL WINAPI SdbWriteStringTag(PDB pdb, TAG tag, LPCWSTR string);
TAGID WINAPI SdbBeginWriteListTag(PDB pdb, TAG tag);
BOOL WINAPI SdbEndWriteListTag(PDB pdb, TAGID tagid);
 
/* sdbapi.c */
void WINAPI SdbCloseDatabase(PDB);
 
/* Copy data to the allocated database */
static void WINAPI SdbpWrite(PDB pdb, const void* data, DWORD size)
{
    ASSERT(pdb->for_write);
    if (pdb->write_iter + size > pdb->size)
    {
        DWORD oldSize = pdb->size;
        /* Round to powers of two to prevent too many reallocations */
        while (pdb->size < pdb->write_iter + size) pdb->size <<= 1;
        pdb->data = SdbReAlloc(pdb->data, pdb->size, oldSize);
    }
 
    memcpy(pdb->data + pdb->write_iter, data, size);
    pdb->write_iter += size;
}
 
/* 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 = pdb->string_buffer;
    ASSERT(pdb->for_write);
 
    if (pdb->string_buffer == NULL)
    {
        pdb->string_buffer = buf = SdbAlloc(sizeof(DB));
        if (buf == NULL)
            return FALSE;
        buf->size = 128;
        buf->data = SdbAlloc(buf->size);
        buf->for_write = TRUE;
        if (buf->data == NULL)
            return FALSE;
    }
 
   *tagid = buf->write_iter + sizeof(TAG) + sizeof(DWORD);
   if (SdbpAddStringToTable(&pdb->string_lookup, string, tagid))
       return SdbWriteStringTag(buf, TAG_STRINGTABLE_ITEM, string);
 
    return pdb->string_lookup != NULL;
}
 
/* Write the in-memory stringtable to the specified db */
static BOOL WINAPI SdbpWriteStringtable(PDB pdb)
{
    TAGID table;
    PDB buf = pdb->string_buffer;
    if (buf == NULL || pdb->string_lookup == NULL)
        return FALSE;
 
    table = SdbBeginWriteListTag(pdb, TAG_STRINGTABLE);
    SdbpWrite(pdb, buf->data, buf->write_iter);
    return SdbEndWriteListTag(pdb, table);
}
 
PDB WINAPI SdbCreateDatabase(LPCWSTR path, PATH_TYPE type)
{
    static const DWORD version_major = 2, version_minor = 1;
    static const char* magic = "sdbf";
    PDB pdb;
 
    pdb = SdbpCreate(path, type, TRUE);
    if (!pdb)
        return NULL;
 
    pdb->size = sizeof(DWORD) + sizeof(DWORD) + (DWORD)strlen(magic);
    pdb->data = SdbAlloc(pdb->size);
 
    SdbpWrite(pdb, &version_major, sizeof(DWORD));
    SdbpWrite(pdb, &version_minor, sizeof(DWORD));
    SdbpWrite(pdb, magic, (DWORD)strlen(magic));
 
    return pdb;
}
 
void WINAPI SdbCloseDatabaseWrite(PDB pdb)
{
    ASSERT(pdb->for_write);
    SdbpWriteStringtable(pdb);
    SdbpFlush(pdb);
    SdbCloseDatabase(pdb);
}
 
BOOL WINAPI SdbWriteNULLTag(PDB pdb, TAG tag)
{
    if (!SdbpCheckTagType(tag, TAG_TYPE_NULL))
        return FALSE;
 
    SdbpWrite(pdb, &tag, sizeof(TAG));
    return TRUE;
}
 
BOOL WINAPI SdbWriteWORDTag(PDB pdb, TAG tag, WORD data)
{
    if (!SdbpCheckTagType(tag, TAG_TYPE_WORD))
        return FALSE;
 
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &data, sizeof(data));
    return TRUE;
}
 
BOOL WINAPI SdbWriteDWORDTag(PDB pdb, TAG tag, DWORD data)
{
    if (!SdbpCheckTagType(tag, TAG_TYPE_DWORD))
        return FALSE;
 
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &data, sizeof(data));
    return TRUE;
}
 
BOOL WINAPI SdbWriteQWORDTag(PDB pdb, TAG tag, QWORD data)
{
    if (!SdbpCheckTagType(tag, TAG_TYPE_QWORD))
        return FALSE;
 
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &data, sizeof(data));
    return TRUE;
}
 
BOOL WINAPI SdbWriteStringTag(PDB pdb, TAG tag, LPCWSTR string)
{
    DWORD size;
 
    if (SdbpCheckTagType(tag, TAG_TYPE_STRINGREF))
    {
        TAGID tagid = 0;
        if (!SdbpGetOrAddStringRef(pdb, string, &tagid))
            return FALSE;
 
        return SdbWriteStringRefTag(pdb, tag, tagid);
    }
 
    if (!SdbpCheckTagType(tag, TAG_TYPE_STRING))
        return FALSE;
 
    size = SdbpStrsize(string);
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &size, sizeof(size));
    SdbpWrite(pdb, string, size);
    return TRUE;
}
 
BOOL WINAPI SdbWriteStringRefTag(PDB pdb, TAG tag, TAGID tagid)
{
    if (!SdbpCheckTagType(tag, TAG_TYPE_STRINGREF))
        return FALSE;
 
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &tagid, sizeof(tagid));
    return TRUE;
}
 
BOOL WINAPI SdbWriteBinaryTag(PDB pdb, TAG tag, const BYTE* data, DWORD size)
{
    if (!SdbpCheckTagType(tag, TAG_TYPE_BINARY))
        return FALSE;
 
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &size, sizeof(size));
    SdbpWrite(pdb, data, size);
    return TRUE;
}
 
#if !defined(SDBWRITE_HOSTTOOL)
BOOL WINAPI SdbWriteBinaryTagFromFile(PDB pdb, TAG tag, LPCWSTR path)
{
    MEMMAPPED mapped;
 
    if (!SdbpCheckTagType(tag, TAG_TYPE_BINARY))
        return FALSE;
 
    if (!SdbpOpenMemMappedFile(path, &mapped))
        return FALSE;
 
    SdbWriteBinaryTag(pdb, tag, mapped.view, mapped.size);
    SdbpCloseMemMappedFile(&mapped);
    return TRUE;
}
#endif
 
TAGID WINAPI SdbBeginWriteListTag(PDB pdb, TAG tag)
{
    TAGID list_id;
    DWORD dum = 0;
 
    if (!SdbpCheckTagType(tag, TAG_TYPE_LIST))
        return TAGID_NULL;
 
    list_id = pdb->write_iter;
    SdbpWrite(pdb, &tag, sizeof(TAG));
    SdbpWrite(pdb, &dum, sizeof(dum)); /* reserve some memory for storing list size */
    return list_id;
}
 
BOOL WINAPI SdbEndWriteListTag(PDB pdb, TAGID tagid)
{
    ASSERT(pdb->for_write);
 
    if (!SdbpCheckTagIDType(pdb, tagid, TAG_TYPE_LIST))
        return FALSE;
 
    /* Write size of list to list tag header */
    *(DWORD*)&pdb->data[tagid + sizeof(TAG)] = pdb->write_iter - tagid - sizeof(TAG) - sizeof(TAGID);
    return TRUE;
}