--- /dev/null
+/*
+ * 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);
+}
projects / reactos.git / commitdiff