[reactos] 02/02: [XOLEHLP] Import xolehlp.dll from Wine(-Staging) 3.21.

[Hermès Bélusca-Maïto]

https://git.reactos.org/?p=reactos.git;a=commitdiff;h=95deef460bc00d66ba81d…

commit 95deef460bc00d66ba81dd0300ca5ab44b25f605
Author:     Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org>
AuthorDate: Fri Nov 30 21:45:36 2018 +0100
Commit:     Hermès Bélusca-Maïto <hermes.belusca-maito(a)reactos.org>
CommitDate: Fri Nov 30 21:49:28 2018 +0100

    [XOLEHLP] Import xolehlp.dll from Wine(-Staging) 3.21.
    
    Should help improving the situation of the Microsoft SQL Server 2005
    Express Edition installer. CORE-15399
---
 dll/win32/CMakeLists.txt         |   1 +
 dll/win32/xolehlp/CMakeLists.txt |  15 +
 dll/win32/xolehlp/xolehlp.c      | 710 +++++++++++++++++++++++++++++++++++++++
 dll/win32/xolehlp/xolehlp.spec   |   6 +
 media/doc/README.WINE            |   1 +
 5 files changed, 733 insertions(+)

diff --git a/dll/win32/CMakeLists.txt b/dll/win32/CMakeLists.txt
index 917c43d06d..8f426f9532 100644
--- a/dll/win32/CMakeLists.txt
+++ b/dll/win32/CMakeLists.txt
@@ -261,3 +261,4 @@ add_subdirectory(xinput1_2)
 add_subdirectory(xinput1_3)
 add_subdirectory(xinput9_1_0)
 add_subdirectory(xmllite)
+add_subdirectory(xolehlp)
diff --git a/dll/win32/xolehlp/CMakeLists.txt b/dll/win32/xolehlp/CMakeLists.txt
new file mode 100644
index 0000000000..28a30d5abe
--- /dev/null
+++ b/dll/win32/xolehlp/CMakeLists.txt
@@ -0,0 +1,15 @@
+
+add_definitions(-D__WINESRC__)
+include_directories(BEFORE ${REACTOS_SOURCE_DIR}/sdk/include/reactos/wine)
+spec2def(xolehlp.dll xolehlp.spec)
+
+list(APPEND SOURCE
+    xolehlp.c
+    ${CMAKE_CURRENT_BINARY_DIR}/xolehlp_stubs.c
+    ${CMAKE_CURRENT_BINARY_DIR}/xolehlp.def)
+
+add_library(xolehlp SHARED ${SOURCE})
+set_module_type(xolehlp win32dll)
+target_link_libraries(xolehlp adsiid uuid wine)
+add_importlibs(xolehlp msvcrt kernel32 ntdll)
+add_cd_file(TARGET xolehlp DESTINATION reactos/system32 FOR all)
diff --git a/dll/win32/xolehlp/xolehlp.c b/dll/win32/xolehlp/xolehlp.c
new file mode 100644
index 0000000000..2a741f4914
--- /dev/null
+++ b/dll/win32/xolehlp/xolehlp.c
@@ -0,0 +1,710 @@
+/*
+ * Copyright 2011 Hans Leidekker for CodeWeavers
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
+ */
+
+#include <stdarg.h>
+#define COBJMACROS
+#include "windef.h"
+#include "winbase.h"
+#include "transact.h"
+#include "initguid.h"
+#include "txdtc.h"
+#include "wine/unicode.h"
+#include "wine/debug.h"
+
+WINE_DEFAULT_DEBUG_CHANNEL(xolehlp);
+
+/* Resource manager start */
+
+typedef struct {
+    IResourceManager IResourceManager_iface;
+    LONG ref;
+} ResourceManager;
+
+static inline ResourceManager *impl_from_IResourceManager(IResourceManager *iface)
+{
+    return CONTAINING_RECORD(iface, ResourceManager, IResourceManager_iface);
+}
+
+static HRESULT WINAPI ResourceManager_QueryInterface(IResourceManager *iface, REFIID
iid,
+    void **ppv)
+{
+    ResourceManager *This = impl_from_IResourceManager(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+    if (!ppv) return E_INVALIDARG;
+
+    if (IsEqualIID(&IID_IUnknown, iid) ||
+        IsEqualIID(&IID_IResourceManager, iid))
+    {
+        *ppv = &This->IResourceManager_iface;
+    }
+    else
+    {
+        FIXME("(%s): not implemented\n", debugstr_guid(iid));
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI ResourceManager_AddRef(IResourceManager *iface)
+{
+    ResourceManager *This = impl_from_IResourceManager(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI ResourceManager_Release(IResourceManager *iface)
+{
+    ResourceManager *This = impl_from_IResourceManager(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+static HRESULT WINAPI ResourceManager_Enlist(IResourceManager *iface,
+	ITransaction *pTransaction,ITransactionResourceAsync *pRes,XACTUOW *pUOW,
+	LONG *pisoLevel,ITransactionEnlistmentAsync **ppEnlist)
+{
+    FIXME("(%p, %p, %p, %p, %p, %p): stub\n", iface, pTransaction,pRes,pUOW,
+        pisoLevel,ppEnlist);
+    return E_NOTIMPL;
+}
+static HRESULT WINAPI ResourceManager_Reenlist(IResourceManager *iface,
+        byte *pPrepInfo,ULONG cbPrepInfo,DWORD lTimeout,XACTSTAT *pXactStat)
+{
+    FIXME("(%p, %p, %u, %u, %p): stub\n", iface, pPrepInfo, cbPrepInfo,
lTimeout, pXactStat);
+    return E_NOTIMPL;
+}
+static HRESULT WINAPI ResourceManager_ReenlistmentComplete(IResourceManager *iface)
+{
+    FIXME("(%p): stub\n", iface);
+    return S_OK;
+}
+static HRESULT WINAPI ResourceManager_GetDistributedTransactionManager(IResourceManager
*iface,
+        REFIID iid,void **ppvObject)
+{
+    FIXME("(%p, %s, %p): stub\n", iface, debugstr_guid(iid), ppvObject);
+    return E_NOTIMPL;
+}
+
+static const IResourceManagerVtbl ResourceManager_Vtbl = {
+    ResourceManager_QueryInterface,
+    ResourceManager_AddRef,
+    ResourceManager_Release,
+    ResourceManager_Enlist,
+    ResourceManager_Reenlist,
+    ResourceManager_ReenlistmentComplete,
+    ResourceManager_GetDistributedTransactionManager
+};
+
+static HRESULT ResourceManager_Create(REFIID riid, void **ppv)
+{
+    ResourceManager *This;
+    HRESULT ret;
+
+    if (!ppv) return E_INVALIDARG;
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(ResourceManager));
+    if (!This) return E_OUTOFMEMORY;
+
+    This->IResourceManager_iface.lpVtbl = &ResourceManager_Vtbl;
+    This->ref = 1;
+
+    ret = IResourceManager_QueryInterface(&This->IResourceManager_iface, riid,
ppv);
+    IResourceManager_Release(&This->IResourceManager_iface);
+
+    return ret;
+}
+
+/* Resource manager end */
+
+/* Transaction options start */
+
+typedef struct {
+    ITransactionOptions ITransactionOptions_iface;
+    LONG ref;
+    XACTOPT opts;
+} TransactionOptions;
+
+static inline TransactionOptions *impl_from_ITransactionOptions(ITransactionOptions
*iface)
+{
+    return CONTAINING_RECORD(iface, TransactionOptions, ITransactionOptions_iface);
+}
+
+static HRESULT WINAPI TransactionOptions_QueryInterface(ITransactionOptions *iface,
REFIID iid,
+    void **ppv)
+{
+    TransactionOptions *This = impl_from_ITransactionOptions(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+    if (!ppv) return E_INVALIDARG;
+
+    if (IsEqualIID(&IID_IUnknown, iid) ||
+        IsEqualIID(&IID_ITransactionOptions, iid))
+    {
+        *ppv = &This->ITransactionOptions_iface;
+    }
+    else
+    {
+        FIXME("(%s): not implemented\n", debugstr_guid(iid));
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI TransactionOptions_AddRef(ITransactionOptions *iface)
+{
+    TransactionOptions *This = impl_from_ITransactionOptions(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI TransactionOptions_Release(ITransactionOptions *iface)
+{
+    TransactionOptions *This = impl_from_ITransactionOptions(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+static HRESULT WINAPI TransactionOptions_SetOptions(ITransactionOptions *iface,
+    XACTOPT *pOptions)
+{
+    TransactionOptions *This = impl_from_ITransactionOptions(iface);
+
+    if (!pOptions) return E_INVALIDARG;
+    TRACE("(%p, %u, %s)\n", iface, pOptions->ulTimeout,
debugstr_a(pOptions->szDescription));
+    This->opts = *pOptions;
+    return S_OK;
+}
+static HRESULT WINAPI TransactionOptions_GetOptions(ITransactionOptions *iface,
+    XACTOPT *pOptions)
+{
+    TransactionOptions *This = impl_from_ITransactionOptions(iface);
+
+    TRACE("(%p, %p)\n", iface, pOptions);
+    if (!pOptions) return E_INVALIDARG;
+    *pOptions = This->opts;
+    return S_OK;
+}
+
+static const ITransactionOptionsVtbl TransactionOptions_Vtbl = {
+    TransactionOptions_QueryInterface,
+    TransactionOptions_AddRef,
+    TransactionOptions_Release,
+    TransactionOptions_SetOptions,
+    TransactionOptions_GetOptions
+};
+
+static HRESULT TransactionOptions_Create(ITransactionOptions **ppv)
+{
+    TransactionOptions *This;
+
+    if (!ppv) return E_INVALIDARG;
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(TransactionOptions));
+    if (!This) return E_OUTOFMEMORY;
+
+    This->ITransactionOptions_iface.lpVtbl = &TransactionOptions_Vtbl;
+    This->ref = 1;
+
+    *ppv = &This->ITransactionOptions_iface;
+
+    return S_OK;
+}
+
+/* Transaction options end */
+
+/* Transaction start */
+
+typedef struct {
+    ITransaction ITransaction_iface;
+    LONG ref;
+    XACTTRANSINFO info;
+} Transaction;
+
+static inline Transaction *impl_from_ITransaction(ITransaction *iface)
+{
+    return CONTAINING_RECORD(iface, Transaction, ITransaction_iface);
+}
+
+static HRESULT WINAPI Transaction_QueryInterface(ITransaction *iface, REFIID iid,
+    void **ppv)
+{
+    Transaction *This = impl_from_ITransaction(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+    if (!ppv) return E_INVALIDARG;
+
+    if (IsEqualIID(&IID_IUnknown, iid) ||
+        IsEqualIID(&IID_ITransaction, iid))
+    {
+        *ppv = &This->ITransaction_iface;
+    }
+    else
+    {
+        FIXME("(%s): not implemented\n", debugstr_guid(iid));
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI Transaction_AddRef(ITransaction *iface)
+{
+    Transaction *This = impl_from_ITransaction(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI Transaction_Release(ITransaction *iface)
+{
+    Transaction *This = impl_from_ITransaction(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+static HRESULT WINAPI Transaction_Commit(ITransaction *iface,
+    BOOL fRetaining, DWORD grfTC, DWORD grfRM)
+{
+    FIXME("(%p, %d, %08x, %08x): stub\n", iface, fRetaining, grfTC, grfRM);
+    return E_NOTIMPL;
+}
+static HRESULT WINAPI Transaction_Abort(ITransaction *iface,
+    BOID *pboidReason, BOOL fRetaining, BOOL fAsync)
+{
+    FIXME("(%p, %p, %d, %d): stub\n", iface, pboidReason, fRetaining, fAsync);
+    return E_NOTIMPL;
+}
+static HRESULT WINAPI Transaction_GetTransactionInfo(ITransaction *iface,
+    XACTTRANSINFO *pinfo)
+{
+    Transaction *This = impl_from_ITransaction(iface);
+    TRACE("(%p, %p)\n", iface, pinfo);
+    if (!pinfo) return E_INVALIDARG;
+    *pinfo = This->info;
+    return S_OK;
+}
+
+static const ITransactionVtbl Transaction_Vtbl = {
+    Transaction_QueryInterface,
+    Transaction_AddRef,
+    Transaction_Release,
+    Transaction_Commit,
+    Transaction_Abort,
+    Transaction_GetTransactionInfo
+};
+
+static HRESULT Transaction_Create(ISOLEVEL isoLevel, ULONG isoFlags,
+        ITransactionOptions *pOptions, ITransaction **ppv)
+{
+    Transaction *This;
+
+    if (!ppv) return E_INVALIDARG;
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(Transaction));
+    if (!This) return E_OUTOFMEMORY;
+    ZeroMemory(&This->info, sizeof(This->info));
+
+    This->ITransaction_iface.lpVtbl = &Transaction_Vtbl;
+    This->ref = 1;
+    This->info.isoLevel = isoLevel;
+    This->info.isoFlags = isoFlags;
+
+    *ppv = &This->ITransaction_iface;
+
+    return S_OK;
+}
+
+/* Transaction end */
+
+/* DTC Proxy Core Object start */
+
+typedef struct {
+    ITransactionDispenser ITransactionDispenser_iface;
+    LONG ref;
+    IResourceManagerFactory2 IResourceManagerFactory2_iface;
+    ITransactionImportWhereabouts ITransactionImportWhereabouts_iface;
+    ITransactionImport ITransactionImport_iface;
+} TransactionManager;
+
+static inline TransactionManager *impl_from_ITransactionDispenser(ITransactionDispenser
*iface)
+{
+    return CONTAINING_RECORD(iface, TransactionManager, ITransactionDispenser_iface);
+}
+
+static HRESULT WINAPI TransactionDispenser_QueryInterface(ITransactionDispenser *iface,
REFIID iid,
+    void **ppv)
+{
+    TransactionManager *This = impl_from_ITransactionDispenser(iface);
+    TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
+
+    if (!ppv) return E_INVALIDARG;
+
+    if (IsEqualIID(&IID_IUnknown, iid) ||
+        IsEqualIID(&IID_ITransactionDispenser, iid))
+    {
+        *ppv = &This->ITransactionDispenser_iface;
+    }
+    else if (IsEqualIID(&IID_IResourceManagerFactory, iid) ||
+        IsEqualIID(&IID_IResourceManagerFactory2, iid))
+    {
+        *ppv = &This->IResourceManagerFactory2_iface;
+    }
+    else if (IsEqualIID(&IID_ITransactionImportWhereabouts, iid))
+    {
+        *ppv = &This->ITransactionImportWhereabouts_iface;
+    }
+    else if (IsEqualIID(&IID_ITransactionImport, iid))
+    {
+        *ppv = &This->ITransactionImport_iface;
+    }
+    else
+    {
+        FIXME("(%s): not implemented\n", debugstr_guid(iid));
+        *ppv = NULL;
+        return E_NOINTERFACE;
+    }
+
+    IUnknown_AddRef((IUnknown*)*ppv);
+    return S_OK;
+}
+
+static ULONG WINAPI TransactionDispenser_AddRef(ITransactionDispenser *iface)
+{
+    TransactionManager *This = impl_from_ITransactionDispenser(iface);
+    ULONG ref = InterlockedIncrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    return ref;
+}
+
+static ULONG WINAPI TransactionDispenser_Release(ITransactionDispenser *iface)
+{
+    TransactionManager *This = impl_from_ITransactionDispenser(iface);
+    ULONG ref = InterlockedDecrement(&This->ref);
+
+    TRACE("(%p) refcount=%u\n", iface, ref);
+
+    if (ref == 0)
+    {
+        HeapFree(GetProcessHeap(), 0, This);
+    }
+
+    return ref;
+}
+
+static HRESULT WINAPI TransactionDispenser_GetOptionsObject(ITransactionDispenser
*iface,
+        ITransactionOptions **ppOptions)
+{
+    TRACE("(%p, %p)\n", iface, ppOptions);
+
+    if (!ppOptions) return E_INVALIDARG;
+    return TransactionOptions_Create(ppOptions);
+}
+static HRESULT WINAPI TransactionDispenser_BeginTransaction(ITransactionDispenser
*iface,
+        IUnknown *punkOuter,
+        ISOLEVEL isoLevel,
+        ULONG isoFlags,
+        ITransactionOptions *pOptions,
+        ITransaction **ppTransaction)
+{
+    FIXME("(%p, %p, %08x, %08x, %p, %p): semi-stub\n", iface, punkOuter,
+        isoLevel, isoFlags, pOptions, ppTransaction);
+
+    if (!ppTransaction) return E_INVALIDARG;
+    if (punkOuter) return CLASS_E_NOAGGREGATION;
+    return Transaction_Create(isoLevel, isoFlags, pOptions, ppTransaction);
+}
+static const ITransactionDispenserVtbl TransactionDispenser_Vtbl = {
+    TransactionDispenser_QueryInterface,
+    TransactionDispenser_AddRef,
+    TransactionDispenser_Release,
+    TransactionDispenser_GetOptionsObject,
+    TransactionDispenser_BeginTransaction
+};
+
+static inline TransactionManager
*impl_from_IResourceManagerFactory2(IResourceManagerFactory2 *iface)
+{
+    return CONTAINING_RECORD(iface, TransactionManager, IResourceManagerFactory2_iface);
+}
+
+static HRESULT WINAPI ResourceManagerFactory2_QueryInterface(IResourceManagerFactory2
*iface, REFIID iid,
+    void **ppv)
+{
+    TransactionManager *This = impl_from_IResourceManagerFactory2(iface);
+    return TransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface,
iid, ppv);
+}
+
+static ULONG WINAPI ResourceManagerFactory2_AddRef(IResourceManagerFactory2 *iface)
+{
+    TransactionManager *This = impl_from_IResourceManagerFactory2(iface);
+    return TransactionDispenser_AddRef(&This->ITransactionDispenser_iface);
+}
+
+static ULONG WINAPI ResourceManagerFactory2_Release(IResourceManagerFactory2 *iface)
+{
+    TransactionManager *This = impl_from_IResourceManagerFactory2(iface);
+    return TransactionDispenser_Release(&This->ITransactionDispenser_iface);
+}
+static HRESULT WINAPI ResourceManagerFactory2_Create(IResourceManagerFactory2 *iface,
+        GUID *pguidRM, CHAR *pszRMName, IResourceManagerSink *pIResMgrSink,
IResourceManager **ppResMgr)
+{
+    FIXME("(%p, %s, %s, %p, %p): semi-stub\n", iface, debugstr_guid(pguidRM),
+        debugstr_a(pszRMName), pIResMgrSink, ppResMgr);
+    return ResourceManager_Create(&IID_IResourceManager, (void**)ppResMgr);
+}
+static HRESULT WINAPI ResourceManagerFactory2_CreateEx(IResourceManagerFactory2 *iface,
+        GUID *pguidRM, CHAR *pszRMName, IResourceManagerSink *pIResMgrSink, REFIID
riidRequested, void **ppResMgr)
+{
+    FIXME("(%p, %s, %s, %p, %s, %p): semi-stub\n", iface,
debugstr_guid(pguidRM),
+        debugstr_a(pszRMName), pIResMgrSink, debugstr_guid(riidRequested), ppResMgr);
+
+    return ResourceManager_Create(riidRequested, ppResMgr);
+}
+static const IResourceManagerFactory2Vtbl ResourceManagerFactory2_Vtbl = {
+    ResourceManagerFactory2_QueryInterface,
+    ResourceManagerFactory2_AddRef,
+    ResourceManagerFactory2_Release,
+    ResourceManagerFactory2_Create,
+    ResourceManagerFactory2_CreateEx
+};
+
+static inline TransactionManager
*impl_from_ITransactionImportWhereabouts(ITransactionImportWhereabouts *iface)
+{
+    return CONTAINING_RECORD(iface, TransactionManager,
ITransactionImportWhereabouts_iface);
+}
+
+static HRESULT WINAPI
TransactionImportWhereabouts_QueryInterface(ITransactionImportWhereabouts *iface, REFIID
iid,
+    void **ppv)
+{
+    TransactionManager *This = impl_from_ITransactionImportWhereabouts(iface);
+    return TransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface,
iid, ppv);
+}
+
+static ULONG WINAPI TransactionImportWhereabouts_AddRef(ITransactionImportWhereabouts
*iface)
+{
+    TransactionManager *This = impl_from_ITransactionImportWhereabouts(iface);
+    return TransactionDispenser_AddRef(&This->ITransactionDispenser_iface);
+}
+
+static ULONG WINAPI TransactionImportWhereabouts_Release(ITransactionImportWhereabouts
*iface)
+{
+    TransactionManager *This = impl_from_ITransactionImportWhereabouts(iface);
+    return TransactionDispenser_Release(&This->ITransactionDispenser_iface);
+}
+static HRESULT WINAPI
TransactionImportWhereabouts_GetWhereaboutsSize(ITransactionImportWhereabouts *iface,
+        ULONG *pcbWhereabouts)
+{
+    FIXME("(%p, %p): stub returning fake value\n", iface, pcbWhereabouts);
+
+    if (!pcbWhereabouts) return E_INVALIDARG;
+    *pcbWhereabouts = 1;
+    return S_OK;
+}
+static HRESULT WINAPI
TransactionImportWhereabouts_GetWhereabouts(ITransactionImportWhereabouts *iface,
+        ULONG cbWhereabouts, BYTE *rgbWhereabouts,ULONG *pcbUsed)
+{
+    FIXME("(%p, %u, %p, %p): stub returning fake value\n", iface,
cbWhereabouts, rgbWhereabouts, pcbUsed);
+
+    if (!rgbWhereabouts || !pcbUsed) return E_INVALIDARG;
+    *rgbWhereabouts = 0;
+    *pcbUsed = 1;
+    return S_OK;
+}
+static const ITransactionImportWhereaboutsVtbl TransactionImportWhereabouts_Vtbl = {
+    TransactionImportWhereabouts_QueryInterface,
+    TransactionImportWhereabouts_AddRef,
+    TransactionImportWhereabouts_Release,
+    TransactionImportWhereabouts_GetWhereaboutsSize,
+    TransactionImportWhereabouts_GetWhereabouts
+};
+
+static inline TransactionManager *impl_from_ITransactionImport(ITransactionImport
*iface)
+{
+    return CONTAINING_RECORD(iface, TransactionManager, ITransactionImport_iface);
+}
+
+static HRESULT WINAPI TransactionImport_QueryInterface(ITransactionImport *iface, REFIID
iid,
+    void **ppv)
+{
+    TransactionManager *This = impl_from_ITransactionImport(iface);
+    return TransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface,
iid, ppv);
+}
+
+static ULONG WINAPI TransactionImport_AddRef(ITransactionImport *iface)
+{
+    TransactionManager *This = impl_from_ITransactionImport(iface);
+    return TransactionDispenser_AddRef(&This->ITransactionDispenser_iface);
+}
+
+static ULONG WINAPI TransactionImport_Release(ITransactionImport *iface)
+{
+    TransactionManager *This = impl_from_ITransactionImport(iface);
+    return TransactionDispenser_Release(&This->ITransactionDispenser_iface);
+}
+static HRESULT WINAPI TransactionImport_Import(ITransactionImport *iface,
+    ULONG cbTransactionCookie, byte *rgbTransactionCookie, IID *piid, void
**ppvTransaction)
+{
+    FIXME("(%p, %u, %p, %s, %p): stub\n", iface, cbTransactionCookie,
rgbTransactionCookie, debugstr_guid(piid), ppvTransaction);
+
+    if (!rgbTransactionCookie || !piid || !ppvTransaction) return E_INVALIDARG;
+    return E_NOTIMPL;
+}
+static const ITransactionImportVtbl TransactionImport_Vtbl = {
+    TransactionImport_QueryInterface,
+    TransactionImport_AddRef,
+    TransactionImport_Release,
+    TransactionImport_Import
+};
+
+static HRESULT TransactionManager_Create(REFIID riid, void **ppv)
+{
+    TransactionManager *This;
+    HRESULT ret;
+
+    This = HeapAlloc(GetProcessHeap(), 0, sizeof(TransactionManager));
+    if (!This) return E_OUTOFMEMORY;
+
+    This->ITransactionDispenser_iface.lpVtbl = &TransactionDispenser_Vtbl;
+    This->IResourceManagerFactory2_iface.lpVtbl = &ResourceManagerFactory2_Vtbl;
+    This->ITransactionImportWhereabouts_iface.lpVtbl =
&TransactionImportWhereabouts_Vtbl;
+    This->ITransactionImport_iface.lpVtbl = &TransactionImport_Vtbl;
+    This->ref = 1;
+
+    ret = ITransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface,
riid, ppv);
+    ITransactionDispenser_Release(&This->ITransactionDispenser_iface);
+
+    return ret;
+}
+/* DTC Proxy Core Object end */
+
+BOOL WINAPI DllMain( HINSTANCE hinst, DWORD reason, LPVOID reserved )
+{
+    TRACE("%p, %u, %p\n", hinst, reason, reserved);
+
+    switch (reason)
+    {
+        case DLL_WINE_PREATTACH:
+            return FALSE;    /* prefer native version */
+        case DLL_PROCESS_ATTACH:
+            DisableThreadLibraryCalls( hinst );
+            break;
+    }
+    return TRUE;
+}
+
+static BOOL is_local_machineA( const CHAR *server )
+{
+    static const CHAR dot[] = ".";
+    CHAR buffer[MAX_COMPUTERNAME_LENGTH + 1];
+    DWORD len = ARRAY_SIZE( buffer );
+
+    if (!server || !strcmp( server, dot )) return TRUE;
+    if (GetComputerNameA( buffer, &len ) && !lstrcmpiA( server, buffer ))
return TRUE;
+    return FALSE;
+}
+static BOOL is_local_machineW( const WCHAR *server )
+{
+    static const WCHAR dotW[] = {'.',0};
+    WCHAR buffer[MAX_COMPUTERNAME_LENGTH + 1];
+    DWORD len = ARRAY_SIZE( buffer );
+
+    if (!server || !strcmpW( server, dotW )) return TRUE;
+    if (GetComputerNameW( buffer, &len ) && !strcmpiW( server, buffer ))
return TRUE;
+    return FALSE;
+}
+
+HRESULT CDECL DtcGetTransactionManager(char *host, char *tm_name, REFIID riid,
+        DWORD dwReserved1, WORD wcbReserved2, void *pvReserved2, void **ppv)
+{
+    TRACE("(%s, %s, %s, %d, %d, %p, %p)\n", debugstr_a(host),
debugstr_a(tm_name),
+          debugstr_guid(riid), dwReserved1, wcbReserved2, pvReserved2, ppv);
+
+    if (!is_local_machineA(host))
+    {
+        FIXME("remote computer not supported\n");
+        return E_NOTIMPL;
+    }
+    return TransactionManager_Create(riid, ppv);
+}
+
+HRESULT CDECL DtcGetTransactionManagerExA(CHAR *host, CHAR *tm_name, REFIID riid,
+        DWORD options, void *config, void **ppv)
+{
+    TRACE("(%s, %s, %s, %d, %p, %p)\n", debugstr_a(host), debugstr_a(tm_name),
+          debugstr_guid(riid), options, config, ppv);
+
+    if (!is_local_machineA(host))
+    {
+        FIXME("remote computer not supported\n");
+        return E_NOTIMPL;
+    }
+    return TransactionManager_Create(riid, ppv);
+}
+
+HRESULT CDECL DtcGetTransactionManagerExW(WCHAR *host, WCHAR *tm_name, REFIID riid,
+        DWORD options, void *config, void **ppv)
+{
+    TRACE("(%s, %s, %s, %d, %p, %p)\n", debugstr_w(host), debugstr_w(tm_name),
+            debugstr_guid(riid), options, config, ppv);
+
+    if (!is_local_machineW(host))
+    {
+        FIXME("remote computer not supported\n");
+        return E_NOTIMPL;
+    }
+    return TransactionManager_Create(riid, ppv);
+}
diff --git a/dll/win32/xolehlp/xolehlp.spec b/dll/win32/xolehlp/xolehlp.spec
new file mode 100644
index 0000000000..80c7c6061a
--- /dev/null
+++ b/dll/win32/xolehlp/xolehlp.spec
@@ -0,0 +1,6 @@
+@ stub GetDtcLocaleResourceHandle
+@ cdecl DtcGetTransactionManager(str str ptr long long ptr ptr)
+@ stub DtcGetTransactionManagerEx
+@ stub DtcGetTransactionManagerC
+@ cdecl DtcGetTransactionManagerExA(str str ptr long ptr ptr)
+@ cdecl DtcGetTransactionManagerExW(wstr wstr ptr long ptr ptr)
diff --git a/media/doc/README.WINE b/media/doc/README.WINE
index a867ad3b16..262dd5743b 100644
--- a/media/doc/README.WINE
+++ b/media/doc/README.WINE
@@ -219,6 +219,7 @@ reactos/dll/win32/xinput1_2           # Synced to WineStaging-2.9
 reactos/dll/win32/xinput1_3           # Synced to WineStaging-2.9
 reactos/dll/win32/xinput9_1_0         # Synced to WineStaging-2.9
 reactos/dll/win32/xmllite             # Synced to WineStaging-3.3
+reactos/dll/win32/xolehlp             # Synced to WineStaging-3.21
 
 reactos/dll/cpl/inetcpl               # Synced to WineStaging-3.17