[1/6] include: add transact.h, txdtc.h and txcoord.h (try 2)
Daniel Jeliński
djelinski1 at gmail.com
Wed May 1 16:17:54 CDT 2013
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.winehq.org/pipermail/wine-patches/attachments/20130501/4cdeb099/attachment-0001.html>
-------------- next part --------------
From 6b7cd0b30b3eaf22d9b9bbef733163e74cc04ca8 Mon Sep 17 00:00:00 2001
From: Daniel Jelinski <djelinski1 at gmail.com>
Date: Wed, 1 May 2013 20:28:10 +0200
Subject: include: add transact.h, txdtc.h and txcoord.h
this time based on minGW headers. Originals found here:
http://sourceforge.net/apps/trac/mingw-w64/browser/experimental/headers_additions_test/include?rev=5374
---
include/transact.h | 434 ++++++++++++
include/txcoord.h | 757 +++++++++++++++++++++
include/txdtc.h | 1887 ++++++++++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 3078 insertions(+), 0 deletions(-)
create mode 100644 include/transact.h
create mode 100644 include/txcoord.h
create mode 100644 include/txdtc.h
diff --git a/include/transact.h b/include/transact.h
new file mode 100644
index 0000000..e3b4ea8
--- /dev/null
+++ b/include/transact.h
@@ -0,0 +1,434 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is derived from the mingw-w64 runtime package.
+ */
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error This stub requires an updated version of <rpcndr.h>
+#endif
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif
+
+#ifndef __transact_h__
+#define __transact_h__
+
+#ifndef __ITransaction_FWD_DEFINED__
+#define __ITransaction_FWD_DEFINED__
+typedef struct ITransaction ITransaction;
+#endif
+
+#ifndef __ITransactionCloner_FWD_DEFINED__
+#define __ITransactionCloner_FWD_DEFINED__
+typedef struct ITransactionCloner ITransactionCloner;
+#endif
+
+#ifndef __ITransaction2_FWD_DEFINED__
+#define __ITransaction2_FWD_DEFINED__
+typedef struct ITransaction2 ITransaction2;
+#endif
+
+#ifndef __ITransactionDispenser_FWD_DEFINED__
+#define __ITransactionDispenser_FWD_DEFINED__
+typedef struct ITransactionDispenser ITransactionDispenser;
+#endif
+
+#ifndef __ITransactionOptions_FWD_DEFINED__
+#define __ITransactionOptions_FWD_DEFINED__
+typedef struct ITransactionOptions ITransactionOptions;
+#endif
+
+#ifndef __ITransactionOutcomeEvents_FWD_DEFINED__
+#define __ITransactionOutcomeEvents_FWD_DEFINED__
+typedef struct ITransactionOutcomeEvents ITransactionOutcomeEvents;
+#endif
+
+#ifndef __ITmNodeName_FWD_DEFINED__
+#define __ITmNodeName_FWD_DEFINED__
+typedef struct ITmNodeName ITmNodeName;
+#endif
+
+#include "unknwn.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include "winerror.h"
+
+ extern RPC_IF_HANDLE __MIDL_itf_transact_0000_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_transact_0000_v0_0_s_ifspec;
+
+#ifndef __BasicTransactionTypes_INTERFACE_DEFINED__
+#define __BasicTransactionTypes_INTERFACE_DEFINED__
+
+ typedef struct BOID {
+ byte rgb[16 ];
+ } BOID;
+
+#define BOID_NULL (*((BOID*)(&IID_NULL)))
+#ifndef MAX_TRAN_DESC_DEFINED
+#define MAX_TRAN_DESC_DEFINED
+ typedef enum TX_MISC_CONSTANTS {
+ MAX_TRAN_DESC = 40
+ } TX_MISC_CONSTANTS;
+#endif
+ typedef BOID XACTUOW;
+ typedef LONG ISOLEVEL;
+
+ typedef enum ISOLATIONLEVEL {
+ ISOLATIONLEVEL_UNSPECIFIED = 0xffffffff,ISOLATIONLEVEL_CHAOS = 0x10,ISOLATIONLEVEL_READUNCOMMITTED = 0x100,ISOLATIONLEVEL_BROWSE = 0x100,
+ ISOLATIONLEVEL_CURSORSTABILITY = 0x1000,ISOLATIONLEVEL_READCOMMITTED = 0x1000,ISOLATIONLEVEL_REPEATABLEREAD = 0x10000,
+ ISOLATIONLEVEL_SERIALIZABLE = 0x100000,ISOLATIONLEVEL_ISOLATED = 0x100000
+ } ISOLATIONLEVEL;
+
+ typedef struct XACTTRANSINFO {
+ XACTUOW uow;
+ ISOLEVEL isoLevel;
+ ULONG isoFlags;
+ DWORD grfTCSupported;
+ DWORD grfRMSupported;
+ DWORD grfTCSupportedRetaining;
+ DWORD grfRMSupportedRetaining;
+ } XACTTRANSINFO;
+
+ typedef struct XACTSTATS {
+ ULONG cOpen;
+ ULONG cCommitting;
+ ULONG cCommitted;
+ ULONG cAborting;
+ ULONG cAborted;
+ ULONG cInDoubt;
+ ULONG cHeuristicDecision;
+ FILETIME timeTransactionsUp;
+ } XACTSTATS;
+
+ typedef enum ISOFLAG {
+ ISOFLAG_RETAIN_COMMIT_DC = 1,ISOFLAG_RETAIN_COMMIT = 2,ISOFLAG_RETAIN_COMMIT_NO = 3,ISOFLAG_RETAIN_ABORT_DC = 4,ISOFLAG_RETAIN_ABORT = 8,
+ ISOFLAG_RETAIN_ABORT_NO = 12,ISOFLAG_RETAIN_DONTCARE = ISOFLAG_RETAIN_COMMIT_DC | ISOFLAG_RETAIN_ABORT_DC,
+ ISOFLAG_RETAIN_BOTH = ISOFLAG_RETAIN_COMMIT | ISOFLAG_RETAIN_ABORT,ISOFLAG_RETAIN_NONE = ISOFLAG_RETAIN_COMMIT_NO | ISOFLAG_RETAIN_ABORT_NO,ISOFLAG_OPTIMISTIC = 16,ISOFLAG_READONLY = 32
+ } ISOFLAG;
+
+ typedef enum XACTTC {
+ XACTTC_NONE = 0,XACTTC_SYNC_PHASEONE = 1,XACTTC_SYNC_PHASETWO = 2,XACTTC_SYNC = 2,XACTTC_ASYNC_PHASEONE = 4,XACTTC_ASYNC = 4
+ } XACTTC;
+
+ typedef enum XACTRM {
+ XACTRM_OPTIMISTICLASTWINS = 1,XACTRM_NOREADONLYPREPARES = 2
+ } XACTRM;
+
+ typedef enum XACTCONST {
+ XACTCONST_TIMEOUTINFINITE = 0
+ } XACTCONST;
+
+ typedef enum XACTHEURISTIC {
+ XACTHEURISTIC_ABORT = 1,XACTHEURISTIC_COMMIT = 2,XACTHEURISTIC_DAMAGE = 3,XACTHEURISTIC_DANGER = 4
+ } XACTHEURISTIC;
+
+ typedef enum XACTSTAT {
+ XACTSTAT_NONE = 0,XACTSTAT_OPENNORMAL = 0x1,XACTSTAT_OPENREFUSED = 0x2,XACTSTAT_PREPARING = 0x4,XACTSTAT_PREPARED = 0x8,XACTSTAT_PREPARERETAINING = 0x10,XACTSTAT_PREPARERETAINED = 0x20,XACTSTAT_COMMITTING = 0x40,XACTSTAT_COMMITRETAINING = 0x80,XACTSTAT_ABORTING = 0x100,XACTSTAT_ABORTED = 0x200,XACTSTAT_COMMITTED = 0x400,XACTSTAT_HEURISTIC_ABORT = 0x800,XACTSTAT_HEURISTIC_COMMIT = 0x1000,XACTSTAT_HEURISTIC_DAMAGE = 0x2000,XACTSTAT_HEURISTIC_DANGER = 0x4000,XACTSTAT_FORCED_ABORT = 0x8000,XACTSTAT_FORCED_COMMIT = 0x10000,XACTSTAT_INDOUBT = 0x20000,XACTSTAT_CLOSED = 0x40000,XACTSTAT_OPEN = 0x3,XACTSTAT_NOTPREPARED = 0x7ffc3,XACTSTAT_ALL = 0x7ffff
+ } XACTSTAT;
+
+ typedef struct XACTOPT {
+ ULONG ulTimeout;
+ char szDescription[40 ];
+ } XACTOPT;
+
+ extern RPC_IF_HANDLE BasicTransactionTypes_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE BasicTransactionTypes_v0_0_s_ifspec;
+#endif
+
+#ifndef __ITransaction_INTERFACE_DEFINED__
+#define __ITransaction_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransaction;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransaction : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Commit(BOOL fRetaining,DWORD grfTC,DWORD grfRM) = 0;
+ virtual HRESULT WINAPI Abort(BOID *pboidReason,BOOL fRetaining,BOOL fAsync) = 0;
+ virtual HRESULT WINAPI GetTransactionInfo(XACTTRANSINFO *pinfo) = 0;
+ };
+#else
+ typedef struct ITransactionVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransaction *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransaction *This);
+ ULONG (WINAPI *Release)(ITransaction *This);
+ HRESULT (WINAPI *Commit)(ITransaction *This,BOOL fRetaining,DWORD grfTC,DWORD grfRM);
+ HRESULT (WINAPI *Abort)(ITransaction *This,BOID *pboidReason,BOOL fRetaining,BOOL fAsync);
+ HRESULT (WINAPI *GetTransactionInfo)(ITransaction *This,XACTTRANSINFO *pinfo);
+ END_INTERFACE
+ } ITransactionVtbl;
+ struct ITransaction {
+ CONST_VTBL struct ITransactionVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransaction_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransaction_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransaction_Release(This) (This)->lpVtbl->Release(This)
+#define ITransaction_Commit(This,fRetaining,grfTC,grfRM) (This)->lpVtbl->Commit(This,fRetaining,grfTC,grfRM)
+#define ITransaction_Abort(This,pboidReason,fRetaining,fAsync) (This)->lpVtbl->Abort(This,pboidReason,fRetaining,fAsync)
+#define ITransaction_GetTransactionInfo(This,pinfo) (This)->lpVtbl->GetTransactionInfo(This,pinfo)
+#endif
+#endif
+ HRESULT WINAPI ITransaction_Commit_Proxy(ITransaction *This,BOOL fRetaining,DWORD grfTC,DWORD grfRM);
+ void __RPC_STUB ITransaction_Commit_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransaction_Abort_Proxy(ITransaction *This,BOID *pboidReason,BOOL fRetaining,BOOL fAsync);
+ void __RPC_STUB ITransaction_Abort_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransaction_GetTransactionInfo_Proxy(ITransaction *This,XACTTRANSINFO *pinfo);
+ void __RPC_STUB ITransaction_GetTransactionInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionCloner_INTERFACE_DEFINED__
+#define __ITransactionCloner_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionCloner;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionCloner : public ITransaction {
+ public:
+ virtual HRESULT WINAPI CloneWithCommitDisabled(ITransaction **ppITransaction) = 0;
+ };
+#else
+ typedef struct ITransactionClonerVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionCloner *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionCloner *This);
+ ULONG (WINAPI *Release)(ITransactionCloner *This);
+ HRESULT (WINAPI *Commit)(ITransactionCloner *This,BOOL fRetaining,DWORD grfTC,DWORD grfRM);
+ HRESULT (WINAPI *Abort)(ITransactionCloner *This,BOID *pboidReason,BOOL fRetaining,BOOL fAsync);
+ HRESULT (WINAPI *GetTransactionInfo)(ITransactionCloner *This,XACTTRANSINFO *pinfo);
+ HRESULT (WINAPI *CloneWithCommitDisabled)(ITransactionCloner *This,ITransaction **ppITransaction);
+ END_INTERFACE
+ } ITransactionClonerVtbl;
+ struct ITransactionCloner {
+ CONST_VTBL struct ITransactionClonerVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionCloner_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionCloner_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionCloner_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionCloner_Commit(This,fRetaining,grfTC,grfRM) (This)->lpVtbl->Commit(This,fRetaining,grfTC,grfRM)
+#define ITransactionCloner_Abort(This,pboidReason,fRetaining,fAsync) (This)->lpVtbl->Abort(This,pboidReason,fRetaining,fAsync)
+#define ITransactionCloner_GetTransactionInfo(This,pinfo) (This)->lpVtbl->GetTransactionInfo(This,pinfo)
+#define ITransactionCloner_CloneWithCommitDisabled(This,ppITransaction) (This)->lpVtbl->CloneWithCommitDisabled(This,ppITransaction)
+#endif
+#endif
+ HRESULT WINAPI ITransactionCloner_CloneWithCommitDisabled_Proxy(ITransactionCloner *This,ITransaction **ppITransaction);
+ void __RPC_STUB ITransactionCloner_CloneWithCommitDisabled_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransaction2_INTERFACE_DEFINED__
+#define __ITransaction2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransaction2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransaction2 : public ITransactionCloner {
+ public:
+ virtual HRESULT WINAPI GetTransactionInfo2(XACTTRANSINFO *pinfo) = 0;
+ };
+#else
+ typedef struct ITransaction2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransaction2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransaction2 *This);
+ ULONG (WINAPI *Release)(ITransaction2 *This);
+ HRESULT (WINAPI *Commit)(ITransaction2 *This,BOOL fRetaining,DWORD grfTC,DWORD grfRM);
+ HRESULT (WINAPI *Abort)(ITransaction2 *This,BOID *pboidReason,BOOL fRetaining,BOOL fAsync);
+ HRESULT (WINAPI *GetTransactionInfo)(ITransaction2 *This,XACTTRANSINFO *pinfo);
+ HRESULT (WINAPI *CloneWithCommitDisabled)(ITransaction2 *This,ITransaction **ppITransaction);
+ HRESULT (WINAPI *GetTransactionInfo2)(ITransaction2 *This,XACTTRANSINFO *pinfo);
+ END_INTERFACE
+ } ITransaction2Vtbl;
+ struct ITransaction2 {
+ CONST_VTBL struct ITransaction2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransaction2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransaction2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransaction2_Release(This) (This)->lpVtbl->Release(This)
+#define ITransaction2_Commit(This,fRetaining,grfTC,grfRM) (This)->lpVtbl->Commit(This,fRetaining,grfTC,grfRM)
+#define ITransaction2_Abort(This,pboidReason,fRetaining,fAsync) (This)->lpVtbl->Abort(This,pboidReason,fRetaining,fAsync)
+#define ITransaction2_GetTransactionInfo(This,pinfo) (This)->lpVtbl->GetTransactionInfo(This,pinfo)
+#define ITransaction2_CloneWithCommitDisabled(This,ppITransaction) (This)->lpVtbl->CloneWithCommitDisabled(This,ppITransaction)
+#define ITransaction2_GetTransactionInfo2(This,pinfo) (This)->lpVtbl->GetTransactionInfo2(This,pinfo)
+#endif
+#endif
+ HRESULT WINAPI ITransaction2_GetTransactionInfo2_Proxy(ITransaction2 *This,XACTTRANSINFO *pinfo);
+ void __RPC_STUB ITransaction2_GetTransactionInfo2_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionDispenser_INTERFACE_DEFINED__
+#define __ITransactionDispenser_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionDispenser;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionDispenser : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetOptionsObject(ITransactionOptions **ppOptions) = 0;
+ virtual HRESULT WINAPI BeginTransaction(IUnknown *punkOuter,ISOLEVEL isoLevel,ULONG isoFlags,ITransactionOptions *pOptions,ITransaction **ppTransaction) = 0;
+ };
+#else
+ typedef struct ITransactionDispenserVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionDispenser *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionDispenser *This);
+ ULONG (WINAPI *Release)(ITransactionDispenser *This);
+ HRESULT (WINAPI *GetOptionsObject)(ITransactionDispenser *This,ITransactionOptions **ppOptions);
+ HRESULT (WINAPI *BeginTransaction)(ITransactionDispenser *This,IUnknown *punkOuter,ISOLEVEL isoLevel,ULONG isoFlags,ITransactionOptions *pOptions,ITransaction **ppTransaction);
+ END_INTERFACE
+ } ITransactionDispenserVtbl;
+ struct ITransactionDispenser {
+ CONST_VTBL struct ITransactionDispenserVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionDispenser_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionDispenser_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionDispenser_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionDispenser_GetOptionsObject(This,ppOptions) (This)->lpVtbl->GetOptionsObject(This,ppOptions)
+#define ITransactionDispenser_BeginTransaction(This,punkOuter,isoLevel,isoFlags,pOptions,ppTransaction) (This)->lpVtbl->BeginTransaction(This,punkOuter,isoLevel,isoFlags,pOptions,ppTransaction)
+#endif
+#endif
+ HRESULT WINAPI ITransactionDispenser_GetOptionsObject_Proxy(ITransactionDispenser *This,ITransactionOptions **ppOptions);
+ void __RPC_STUB ITransactionDispenser_GetOptionsObject_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionDispenser_BeginTransaction_Proxy(ITransactionDispenser *This,IUnknown *punkOuter,ISOLEVEL isoLevel,ULONG isoFlags,ITransactionOptions *pOptions,ITransaction **ppTransaction);
+ void __RPC_STUB ITransactionDispenser_BeginTransaction_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionOptions_INTERFACE_DEFINED__
+#define __ITransactionOptions_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionOptions;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionOptions : public IUnknown {
+ public:
+ virtual HRESULT WINAPI SetOptions(XACTOPT *pOptions) = 0;
+ virtual HRESULT WINAPI GetOptions(XACTOPT *pOptions) = 0;
+ };
+#else
+ typedef struct ITransactionOptionsVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionOptions *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionOptions *This);
+ ULONG (WINAPI *Release)(ITransactionOptions *This);
+ HRESULT (WINAPI *SetOptions)(ITransactionOptions *This,XACTOPT *pOptions);
+ HRESULT (WINAPI *GetOptions)(ITransactionOptions *This,XACTOPT *pOptions);
+ END_INTERFACE
+ } ITransactionOptionsVtbl;
+ struct ITransactionOptions {
+ CONST_VTBL struct ITransactionOptionsVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionOptions_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionOptions_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionOptions_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionOptions_SetOptions(This,pOptions) (This)->lpVtbl->SetOptions(This,pOptions)
+#define ITransactionOptions_GetOptions(This,pOptions) (This)->lpVtbl->GetOptions(This,pOptions)
+#endif
+#endif
+ HRESULT WINAPI ITransactionOptions_SetOptions_Proxy(ITransactionOptions *This,XACTOPT *pOptions);
+ void __RPC_STUB ITransactionOptions_SetOptions_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionOptions_GetOptions_Proxy(ITransactionOptions *This,XACTOPT *pOptions);
+ void __RPC_STUB ITransactionOptions_GetOptions_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionOutcomeEvents_INTERFACE_DEFINED__
+#define __ITransactionOutcomeEvents_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionOutcomeEvents;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionOutcomeEvents : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Committed(BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr) = 0;
+ virtual HRESULT WINAPI Aborted(BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr) = 0;
+ virtual HRESULT WINAPI HeuristicDecision(DWORD dwDecision,BOID *pboidReason,HRESULT hr) = 0;
+ virtual HRESULT WINAPI Indoubt(void) = 0;
+ };
+#else
+ typedef struct ITransactionOutcomeEventsVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionOutcomeEvents *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionOutcomeEvents *This);
+ ULONG (WINAPI *Release)(ITransactionOutcomeEvents *This);
+ HRESULT (WINAPI *Committed)(ITransactionOutcomeEvents *This,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr);
+ HRESULT (WINAPI *Aborted)(ITransactionOutcomeEvents *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr);
+ HRESULT (WINAPI *HeuristicDecision)(ITransactionOutcomeEvents *This,DWORD dwDecision,BOID *pboidReason,HRESULT hr);
+ HRESULT (WINAPI *Indoubt)(ITransactionOutcomeEvents *This);
+ END_INTERFACE
+ } ITransactionOutcomeEventsVtbl;
+ struct ITransactionOutcomeEvents {
+ CONST_VTBL struct ITransactionOutcomeEventsVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionOutcomeEvents_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionOutcomeEvents_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionOutcomeEvents_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionOutcomeEvents_Committed(This,fRetaining,pNewUOW,hr) (This)->lpVtbl->Committed(This,fRetaining,pNewUOW,hr)
+#define ITransactionOutcomeEvents_Aborted(This,pboidReason,fRetaining,pNewUOW,hr) (This)->lpVtbl->Aborted(This,pboidReason,fRetaining,pNewUOW,hr)
+#define ITransactionOutcomeEvents_HeuristicDecision(This,dwDecision,pboidReason,hr) (This)->lpVtbl->HeuristicDecision(This,dwDecision,pboidReason,hr)
+#define ITransactionOutcomeEvents_Indoubt(This) (This)->lpVtbl->Indoubt(This)
+#endif
+#endif
+ HRESULT WINAPI ITransactionOutcomeEvents_Committed_Proxy(ITransactionOutcomeEvents *This,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr);
+ void __RPC_STUB ITransactionOutcomeEvents_Committed_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionOutcomeEvents_Aborted_Proxy(ITransactionOutcomeEvents *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr);
+ void __RPC_STUB ITransactionOutcomeEvents_Aborted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionOutcomeEvents_HeuristicDecision_Proxy(ITransactionOutcomeEvents *This,DWORD dwDecision,BOID *pboidReason,HRESULT hr);
+ void __RPC_STUB ITransactionOutcomeEvents_HeuristicDecision_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionOutcomeEvents_Indoubt_Proxy(ITransactionOutcomeEvents *This);
+ void __RPC_STUB ITransactionOutcomeEvents_Indoubt_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITmNodeName_INTERFACE_DEFINED__
+#define __ITmNodeName_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITmNodeName;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITmNodeName : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetNodeNameSize(ULONG *pcbNodeNameSize) = 0;
+ virtual HRESULT WINAPI GetNodeName(ULONG cbNodeNameBufferSize,LPWSTR pNodeNameBuffer) = 0;
+ };
+#else
+ typedef struct ITmNodeNameVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITmNodeName *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITmNodeName *This);
+ ULONG (WINAPI *Release)(ITmNodeName *This);
+ HRESULT (WINAPI *GetNodeNameSize)(ITmNodeName *This,ULONG *pcbNodeNameSize);
+ HRESULT (WINAPI *GetNodeName)(ITmNodeName *This,ULONG cbNodeNameBufferSize,LPWSTR pNodeNameBuffer);
+ END_INTERFACE
+ } ITmNodeNameVtbl;
+ struct ITmNodeName {
+ CONST_VTBL struct ITmNodeNameVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITmNodeName_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITmNodeName_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITmNodeName_Release(This) (This)->lpVtbl->Release(This)
+#define ITmNodeName_GetNodeNameSize(This,pcbNodeNameSize) (This)->lpVtbl->GetNodeNameSize(This,pcbNodeNameSize)
+#define ITmNodeName_GetNodeName(This,cbNodeNameBufferSize,pNodeNameBuffer) (This)->lpVtbl->GetNodeName(This,cbNodeNameBufferSize,pNodeNameBuffer)
+#endif
+#endif
+ HRESULT WINAPI ITmNodeName_GetNodeNameSize_Proxy(ITmNodeName *This,ULONG *pcbNodeNameSize);
+ void __RPC_STUB ITmNodeName_GetNodeNameSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITmNodeName_GetNodeName_Proxy(ITmNodeName *This,ULONG cbNodeNameBufferSize,LPWSTR pNodeNameBuffer);
+ void __RPC_STUB ITmNodeName_GetNodeName_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+ DEFINE_GUID(IID_ITransaction,0x0fb15084,0xaf41,0x11ce,0xbd,0x2b,0x20,0x4c,0x4f,0x4f,0x50,0x20);
+ DEFINE_GUID(IID_ITransactionCloner,0x02656950,0x2152,0x11d0,0x94,0x4C,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_ITransaction2,0x34021548,0x0065,0x11d3,0xba,0xc1,0x00,0xc0,0x4f,0x79,0x7b,0xe2);
+ DEFINE_GUID(IID_ITransactionDispenser,0x3A6AD9E1,0x23B9,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD);
+ DEFINE_GUID(IID_ITransactionOptions,0x3A6AD9E0,0x23B9,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD);
+ DEFINE_GUID(IID_ITransactionOutcomeEvents,0x3A6AD9E2,0x23B9,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD);
+ DEFINE_GUID(IID_ITmNodeName,0x30274F88,0x6EE4,0x474e,0x9B,0x95,0x78,0x07,0xBC,0x9E,0xF8,0xCF);
+
+ extern RPC_IF_HANDLE __MIDL_itf_transact_0016_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_transact_0016_v0_0_s_ifspec;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/include/txcoord.h b/include/txcoord.h
new file mode 100644
index 0000000..ad8478f
--- /dev/null
+++ b/include/txcoord.h
@@ -0,0 +1,757 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is derived from the mingw-w64 runtime package.
+ */
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error This stub requires an updated version of <rpcndr.h>
+#endif
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif
+
+#ifndef __txcoord_h__
+#define __txcoord_h__
+
+#ifndef __ITransactionResourceAsync_FWD_DEFINED__
+#define __ITransactionResourceAsync_FWD_DEFINED__
+typedef struct ITransactionResourceAsync ITransactionResourceAsync;
+#endif
+
+#ifndef __ITransactionLastResourceAsync_FWD_DEFINED__
+#define __ITransactionLastResourceAsync_FWD_DEFINED__
+typedef struct ITransactionLastResourceAsync ITransactionLastResourceAsync;
+#endif
+
+#ifndef __ITransactionResource_FWD_DEFINED__
+#define __ITransactionResource_FWD_DEFINED__
+typedef struct ITransactionResource ITransactionResource;
+#endif
+
+#ifndef __ITransactionEnlistmentAsync_FWD_DEFINED__
+#define __ITransactionEnlistmentAsync_FWD_DEFINED__
+typedef struct ITransactionEnlistmentAsync ITransactionEnlistmentAsync;
+#endif
+
+#ifndef __ITransactionLastEnlistmentAsync_FWD_DEFINED__
+#define __ITransactionLastEnlistmentAsync_FWD_DEFINED__
+typedef struct ITransactionLastEnlistmentAsync ITransactionLastEnlistmentAsync;
+#endif
+
+#ifndef __ITransactionExportFactory_FWD_DEFINED__
+#define __ITransactionExportFactory_FWD_DEFINED__
+typedef struct ITransactionExportFactory ITransactionExportFactory;
+#endif
+
+#ifndef __ITransactionImportWhereabouts_FWD_DEFINED__
+#define __ITransactionImportWhereabouts_FWD_DEFINED__
+typedef struct ITransactionImportWhereabouts ITransactionImportWhereabouts;
+#endif
+
+#ifndef __ITransactionExport_FWD_DEFINED__
+#define __ITransactionExport_FWD_DEFINED__
+typedef struct ITransactionExport ITransactionExport;
+#endif
+
+#ifndef __ITransactionImport_FWD_DEFINED__
+#define __ITransactionImport_FWD_DEFINED__
+typedef struct ITransactionImport ITransactionImport;
+#endif
+
+#ifndef __ITipTransaction_FWD_DEFINED__
+#define __ITipTransaction_FWD_DEFINED__
+typedef struct ITipTransaction ITipTransaction;
+#endif
+
+#ifndef __ITipHelper_FWD_DEFINED__
+#define __ITipHelper_FWD_DEFINED__
+typedef struct ITipHelper ITipHelper;
+#endif
+
+#ifndef __ITipPullSink_FWD_DEFINED__
+#define __ITipPullSink_FWD_DEFINED__
+typedef struct ITipPullSink ITipPullSink;
+#endif
+
+#ifndef __IDtcNetworkAccessConfig_FWD_DEFINED__
+#define __IDtcNetworkAccessConfig_FWD_DEFINED__
+typedef struct IDtcNetworkAccessConfig IDtcNetworkAccessConfig;
+#endif
+
+#ifndef __IDtcNetworkAccessConfig2_FWD_DEFINED__
+#define __IDtcNetworkAccessConfig2_FWD_DEFINED__
+typedef struct IDtcNetworkAccessConfig2 IDtcNetworkAccessConfig2;
+#endif
+
+#include "transact.h"
+#include "objidl.h"
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ extern RPC_IF_HANDLE __MIDL_itf_txcoord_0000_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txcoord_0000_v0_0_s_ifspec;
+
+#ifndef __ITransactionResourceAsync_INTERFACE_DEFINED__
+#define __ITransactionResourceAsync_INTERFACE_DEFINED__
+
+ EXTERN_C const IID IID_ITransactionResourceAsync;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionResourceAsync : public IUnknown {
+ public:
+ virtual HRESULT WINAPI PrepareRequest(BOOL fRetaining,DWORD grfRM,BOOL fWantMoniker,BOOL fSinglePhase) = 0;
+ virtual HRESULT WINAPI CommitRequest(DWORD grfRM,XACTUOW *pNewUOW) = 0;
+ virtual HRESULT WINAPI AbortRequest(BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW) = 0;
+ virtual HRESULT WINAPI TMDown(void) = 0;
+ };
+#else
+ typedef struct ITransactionResourceAsyncVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionResourceAsync *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionResourceAsync *This);
+ ULONG (WINAPI *Release)(ITransactionResourceAsync *This);
+ HRESULT (WINAPI *PrepareRequest)(ITransactionResourceAsync *This,BOOL fRetaining,DWORD grfRM,BOOL fWantMoniker,BOOL fSinglePhase);
+ HRESULT (WINAPI *CommitRequest)(ITransactionResourceAsync *This,DWORD grfRM,XACTUOW *pNewUOW);
+ HRESULT (WINAPI *AbortRequest)(ITransactionResourceAsync *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW);
+ HRESULT (WINAPI *TMDown)(ITransactionResourceAsync *This);
+ END_INTERFACE
+ } ITransactionResourceAsyncVtbl;
+ struct ITransactionResourceAsync {
+ CONST_VTBL struct ITransactionResourceAsyncVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionResourceAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionResourceAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionResourceAsync_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionResourceAsync_PrepareRequest(This,fRetaining,grfRM,fWantMoniker,fSinglePhase) (This)->lpVtbl->PrepareRequest(This,fRetaining,grfRM,fWantMoniker,fSinglePhase)
+#define ITransactionResourceAsync_CommitRequest(This,grfRM,pNewUOW) (This)->lpVtbl->CommitRequest(This,grfRM,pNewUOW)
+#define ITransactionResourceAsync_AbortRequest(This,pboidReason,fRetaining,pNewUOW) (This)->lpVtbl->AbortRequest(This,pboidReason,fRetaining,pNewUOW)
+#define ITransactionResourceAsync_TMDown(This) (This)->lpVtbl->TMDown(This)
+#endif
+#endif
+ HRESULT WINAPI ITransactionResourceAsync_PrepareRequest_Proxy(ITransactionResourceAsync *This,BOOL fRetaining,DWORD grfRM,BOOL fWantMoniker,BOOL fSinglePhase);
+ void __RPC_STUB ITransactionResourceAsync_PrepareRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionResourceAsync_CommitRequest_Proxy(ITransactionResourceAsync *This,DWORD grfRM,XACTUOW *pNewUOW);
+ void __RPC_STUB ITransactionResourceAsync_CommitRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionResourceAsync_AbortRequest_Proxy(ITransactionResourceAsync *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW);
+ void __RPC_STUB ITransactionResourceAsync_AbortRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionResourceAsync_TMDown_Proxy(ITransactionResourceAsync *This);
+ void __RPC_STUB ITransactionResourceAsync_TMDown_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionLastResourceAsync_INTERFACE_DEFINED__
+#define __ITransactionLastResourceAsync_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionLastResourceAsync;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionLastResourceAsync : public IUnknown {
+ public:
+ virtual HRESULT WINAPI DelegateCommit(DWORD grfRM) = 0;
+ virtual HRESULT WINAPI ForgetRequest(XACTUOW *pNewUOW) = 0;
+ };
+#else
+ typedef struct ITransactionLastResourceAsyncVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionLastResourceAsync *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionLastResourceAsync *This);
+ ULONG (WINAPI *Release)(ITransactionLastResourceAsync *This);
+ HRESULT (WINAPI *DelegateCommit)(ITransactionLastResourceAsync *This,DWORD grfRM);
+ HRESULT (WINAPI *ForgetRequest)(ITransactionLastResourceAsync *This,XACTUOW *pNewUOW);
+ END_INTERFACE
+ } ITransactionLastResourceAsyncVtbl;
+ struct ITransactionLastResourceAsync {
+ CONST_VTBL struct ITransactionLastResourceAsyncVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionLastResourceAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionLastResourceAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionLastResourceAsync_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionLastResourceAsync_DelegateCommit(This,grfRM) (This)->lpVtbl->DelegateCommit(This,grfRM)
+#define ITransactionLastResourceAsync_ForgetRequest(This,pNewUOW) (This)->lpVtbl->ForgetRequest(This,pNewUOW)
+#endif
+#endif
+ HRESULT WINAPI ITransactionLastResourceAsync_DelegateCommit_Proxy(ITransactionLastResourceAsync *This,DWORD grfRM);
+ void __RPC_STUB ITransactionLastResourceAsync_DelegateCommit_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionLastResourceAsync_ForgetRequest_Proxy(ITransactionLastResourceAsync *This,XACTUOW *pNewUOW);
+ void __RPC_STUB ITransactionLastResourceAsync_ForgetRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionResource_INTERFACE_DEFINED__
+#define __ITransactionResource_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionResource;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionResource : public IUnknown {
+ public:
+ virtual HRESULT WINAPI PrepareRequest(BOOL fRetaining,DWORD grfRM,BOOL fWantMoniker,BOOL fSinglePhase) = 0;
+ virtual HRESULT WINAPI CommitRequest(DWORD grfRM,XACTUOW *pNewUOW) = 0;
+ virtual HRESULT WINAPI AbortRequest(BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW) = 0;
+ virtual HRESULT WINAPI TMDown(void) = 0;
+ };
+#else
+ typedef struct ITransactionResourceVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionResource *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionResource *This);
+ ULONG (WINAPI *Release)(ITransactionResource *This);
+ HRESULT (WINAPI *PrepareRequest)(ITransactionResource *This,BOOL fRetaining,DWORD grfRM,BOOL fWantMoniker,BOOL fSinglePhase);
+ HRESULT (WINAPI *CommitRequest)(ITransactionResource *This,DWORD grfRM,XACTUOW *pNewUOW);
+ HRESULT (WINAPI *AbortRequest)(ITransactionResource *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW);
+ HRESULT (WINAPI *TMDown)(ITransactionResource *This);
+ END_INTERFACE
+ } ITransactionResourceVtbl;
+ struct ITransactionResource {
+ CONST_VTBL struct ITransactionResourceVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionResource_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionResource_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionResource_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionResource_PrepareRequest(This,fRetaining,grfRM,fWantMoniker,fSinglePhase) (This)->lpVtbl->PrepareRequest(This,fRetaining,grfRM,fWantMoniker,fSinglePhase)
+#define ITransactionResource_CommitRequest(This,grfRM,pNewUOW) (This)->lpVtbl->CommitRequest(This,grfRM,pNewUOW)
+#define ITransactionResource_AbortRequest(This,pboidReason,fRetaining,pNewUOW) (This)->lpVtbl->AbortRequest(This,pboidReason,fRetaining,pNewUOW)
+#define ITransactionResource_TMDown(This) (This)->lpVtbl->TMDown(This)
+#endif
+#endif
+ HRESULT WINAPI ITransactionResource_PrepareRequest_Proxy(ITransactionResource *This,BOOL fRetaining,DWORD grfRM,BOOL fWantMoniker,BOOL fSinglePhase);
+ void __RPC_STUB ITransactionResource_PrepareRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionResource_CommitRequest_Proxy(ITransactionResource *This,DWORD grfRM,XACTUOW *pNewUOW);
+ void __RPC_STUB ITransactionResource_CommitRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionResource_AbortRequest_Proxy(ITransactionResource *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW);
+ void __RPC_STUB ITransactionResource_AbortRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionResource_TMDown_Proxy(ITransactionResource *This);
+ void __RPC_STUB ITransactionResource_TMDown_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionEnlistmentAsync_INTERFACE_DEFINED__
+#define __ITransactionEnlistmentAsync_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionEnlistmentAsync;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionEnlistmentAsync : public IUnknown {
+ public:
+ virtual HRESULT WINAPI PrepareRequestDone(HRESULT hr,IMoniker *pmk,BOID *pboidReason) = 0;
+ virtual HRESULT WINAPI CommitRequestDone(HRESULT hr) = 0;
+ virtual HRESULT WINAPI AbortRequestDone(HRESULT hr) = 0;
+ };
+#else
+ typedef struct ITransactionEnlistmentAsyncVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionEnlistmentAsync *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionEnlistmentAsync *This);
+ ULONG (WINAPI *Release)(ITransactionEnlistmentAsync *This);
+ HRESULT (WINAPI *PrepareRequestDone)(ITransactionEnlistmentAsync *This,HRESULT hr,IMoniker *pmk,BOID *pboidReason);
+ HRESULT (WINAPI *CommitRequestDone)(ITransactionEnlistmentAsync *This,HRESULT hr);
+ HRESULT (WINAPI *AbortRequestDone)(ITransactionEnlistmentAsync *This,HRESULT hr);
+ END_INTERFACE
+ } ITransactionEnlistmentAsyncVtbl;
+ struct ITransactionEnlistmentAsync {
+ CONST_VTBL struct ITransactionEnlistmentAsyncVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionEnlistmentAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionEnlistmentAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionEnlistmentAsync_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionEnlistmentAsync_PrepareRequestDone(This,hr,pmk,pboidReason) (This)->lpVtbl->PrepareRequestDone(This,hr,pmk,pboidReason)
+#define ITransactionEnlistmentAsync_CommitRequestDone(This,hr) (This)->lpVtbl->CommitRequestDone(This,hr)
+#define ITransactionEnlistmentAsync_AbortRequestDone(This,hr) (This)->lpVtbl->AbortRequestDone(This,hr)
+#endif
+#endif
+ HRESULT WINAPI ITransactionEnlistmentAsync_PrepareRequestDone_Proxy(ITransactionEnlistmentAsync *This,HRESULT hr,IMoniker *pmk,BOID *pboidReason);
+ void __RPC_STUB ITransactionEnlistmentAsync_PrepareRequestDone_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionEnlistmentAsync_CommitRequestDone_Proxy(ITransactionEnlistmentAsync *This,HRESULT hr);
+ void __RPC_STUB ITransactionEnlistmentAsync_CommitRequestDone_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionEnlistmentAsync_AbortRequestDone_Proxy(ITransactionEnlistmentAsync *This,HRESULT hr);
+ void __RPC_STUB ITransactionEnlistmentAsync_AbortRequestDone_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionLastEnlistmentAsync_INTERFACE_DEFINED__
+#define __ITransactionLastEnlistmentAsync_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionLastEnlistmentAsync;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionLastEnlistmentAsync : public IUnknown {
+ public:
+ virtual HRESULT WINAPI TransactionOutcome(XACTSTAT XactStat,BOID *pboidReason) = 0;
+ };
+#else
+ typedef struct ITransactionLastEnlistmentAsyncVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionLastEnlistmentAsync *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionLastEnlistmentAsync *This);
+ ULONG (WINAPI *Release)(ITransactionLastEnlistmentAsync *This);
+ HRESULT (WINAPI *TransactionOutcome)(ITransactionLastEnlistmentAsync *This,XACTSTAT XactStat,BOID *pboidReason);
+ END_INTERFACE
+ } ITransactionLastEnlistmentAsyncVtbl;
+ struct ITransactionLastEnlistmentAsync {
+ CONST_VTBL struct ITransactionLastEnlistmentAsyncVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionLastEnlistmentAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionLastEnlistmentAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionLastEnlistmentAsync_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionLastEnlistmentAsync_TransactionOutcome(This,XactStat,pboidReason) (This)->lpVtbl->TransactionOutcome(This,XactStat,pboidReason)
+#endif
+#endif
+ HRESULT WINAPI ITransactionLastEnlistmentAsync_TransactionOutcome_Proxy(ITransactionLastEnlistmentAsync *This,XACTSTAT XactStat,BOID *pboidReason);
+ void __RPC_STUB ITransactionLastEnlistmentAsync_TransactionOutcome_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionExportFactory_INTERFACE_DEFINED__
+#define __ITransactionExportFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionExportFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionExportFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetRemoteClassId(CLSID *pclsid) = 0;
+ virtual HRESULT WINAPI Create(ULONG cbWhereabouts,byte *rgbWhereabouts,ITransactionExport **ppExport) = 0;
+ };
+#else
+ typedef struct ITransactionExportFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionExportFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionExportFactory *This);
+ ULONG (WINAPI *Release)(ITransactionExportFactory *This);
+ HRESULT (WINAPI *GetRemoteClassId)(ITransactionExportFactory *This,CLSID *pclsid);
+ HRESULT (WINAPI *Create)(ITransactionExportFactory *This,ULONG cbWhereabouts,byte *rgbWhereabouts,ITransactionExport **ppExport);
+ END_INTERFACE
+ } ITransactionExportFactoryVtbl;
+ struct ITransactionExportFactory {
+ CONST_VTBL struct ITransactionExportFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionExportFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionExportFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionExportFactory_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionExportFactory_GetRemoteClassId(This,pclsid) (This)->lpVtbl->GetRemoteClassId(This,pclsid)
+#define ITransactionExportFactory_Create(This,cbWhereabouts,rgbWhereabouts,ppExport) (This)->lpVtbl->Create(This,cbWhereabouts,rgbWhereabouts,ppExport)
+#endif
+#endif
+ HRESULT WINAPI ITransactionExportFactory_GetRemoteClassId_Proxy(ITransactionExportFactory *This,CLSID *pclsid);
+ void __RPC_STUB ITransactionExportFactory_GetRemoteClassId_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionExportFactory_Create_Proxy(ITransactionExportFactory *This,ULONG cbWhereabouts,byte *rgbWhereabouts,ITransactionExport **ppExport);
+ void __RPC_STUB ITransactionExportFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionImportWhereabouts_INTERFACE_DEFINED__
+#define __ITransactionImportWhereabouts_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionImportWhereabouts;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionImportWhereabouts : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetWhereaboutsSize(ULONG *pcbWhereabouts) = 0;
+ virtual HRESULT WINAPI GetWhereabouts(ULONG cbWhereabouts,byte *rgbWhereabouts,ULONG *pcbUsed) = 0;
+ };
+#else
+ typedef struct ITransactionImportWhereaboutsVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionImportWhereabouts *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionImportWhereabouts *This);
+ ULONG (WINAPI *Release)(ITransactionImportWhereabouts *This);
+ HRESULT (WINAPI *GetWhereaboutsSize)(ITransactionImportWhereabouts *This,ULONG *pcbWhereabouts);
+ HRESULT (WINAPI *GetWhereabouts)(ITransactionImportWhereabouts *This,ULONG cbWhereabouts,byte *rgbWhereabouts,ULONG *pcbUsed);
+ END_INTERFACE
+ } ITransactionImportWhereaboutsVtbl;
+ struct ITransactionImportWhereabouts {
+ CONST_VTBL struct ITransactionImportWhereaboutsVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionImportWhereabouts_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionImportWhereabouts_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionImportWhereabouts_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionImportWhereabouts_GetWhereaboutsSize(This,pcbWhereabouts) (This)->lpVtbl->GetWhereaboutsSize(This,pcbWhereabouts)
+#define ITransactionImportWhereabouts_GetWhereabouts(This,cbWhereabouts,rgbWhereabouts,pcbUsed) (This)->lpVtbl->GetWhereabouts(This,cbWhereabouts,rgbWhereabouts,pcbUsed)
+#endif
+#endif
+ HRESULT WINAPI ITransactionImportWhereabouts_GetWhereaboutsSize_Proxy(ITransactionImportWhereabouts *This,ULONG *pcbWhereabouts);
+ void __RPC_STUB ITransactionImportWhereabouts_GetWhereaboutsSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionImportWhereabouts_RemoteGetWhereabouts_Proxy(ITransactionImportWhereabouts *This,ULONG *pcbUsed,ULONG cbWhereabouts,byte *rgbWhereabouts);
+ void __RPC_STUB ITransactionImportWhereabouts_RemoteGetWhereabouts_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionExport_INTERFACE_DEFINED__
+#define __ITransactionExport_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionExport;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionExport : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Export(IUnknown *punkTransaction,ULONG *pcbTransactionCookie) = 0;
+ virtual HRESULT WINAPI GetTransactionCookie(IUnknown *punkTransaction,ULONG cbTransactionCookie,byte *rgbTransactionCookie,ULONG *pcbUsed) = 0;
+ };
+#else
+ typedef struct ITransactionExportVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionExport *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionExport *This);
+ ULONG (WINAPI *Release)(ITransactionExport *This);
+ HRESULT (WINAPI *Export)(ITransactionExport *This,IUnknown *punkTransaction,ULONG *pcbTransactionCookie);
+ HRESULT (WINAPI *GetTransactionCookie)(ITransactionExport *This,IUnknown *punkTransaction,ULONG cbTransactionCookie,byte *rgbTransactionCookie,ULONG *pcbUsed);
+ END_INTERFACE
+ } ITransactionExportVtbl;
+ struct ITransactionExport {
+ CONST_VTBL struct ITransactionExportVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionExport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionExport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionExport_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionExport_Export(This,punkTransaction,pcbTransactionCookie) (This)->lpVtbl->Export(This,punkTransaction,pcbTransactionCookie)
+#define ITransactionExport_GetTransactionCookie(This,punkTransaction,cbTransactionCookie,rgbTransactionCookie,pcbUsed) (This)->lpVtbl->GetTransactionCookie(This,punkTransaction,cbTransactionCookie,rgbTransactionCookie,pcbUsed)
+#endif
+#endif
+ HRESULT WINAPI ITransactionExport_Export_Proxy(ITransactionExport *This,IUnknown *punkTransaction,ULONG *pcbTransactionCookie);
+ void __RPC_STUB ITransactionExport_Export_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionExport_RemoteGetTransactionCookie_Proxy(ITransactionExport *This,IUnknown *punkTransaction,ULONG *pcbUsed,ULONG cbTransactionCookie,byte *rgbTransactionCookie);
+ void __RPC_STUB ITransactionExport_RemoteGetTransactionCookie_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionImport_INTERFACE_DEFINED__
+#define __ITransactionImport_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionImport;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionImport : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Import(ULONG cbTransactionCookie,byte *rgbTransactionCookie,IID *piid,void **ppvTransaction) = 0;
+ };
+#else
+ typedef struct ITransactionImportVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionImport *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionImport *This);
+ ULONG (WINAPI *Release)(ITransactionImport *This);
+ HRESULT (WINAPI *Import)(ITransactionImport *This,ULONG cbTransactionCookie,byte *rgbTransactionCookie,IID *piid,void **ppvTransaction);
+ END_INTERFACE
+ } ITransactionImportVtbl;
+ struct ITransactionImport {
+ CONST_VTBL struct ITransactionImportVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionImport_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionImport_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionImport_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionImport_Import(This,cbTransactionCookie,rgbTransactionCookie,piid,ppvTransaction) (This)->lpVtbl->Import(This,cbTransactionCookie,rgbTransactionCookie,piid,ppvTransaction)
+#endif
+#endif
+ HRESULT WINAPI ITransactionImport_Import_Proxy(ITransactionImport *This,ULONG cbTransactionCookie,byte *rgbTransactionCookie,IID *piid,void **ppvTransaction);
+ void __RPC_STUB ITransactionImport_Import_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITipTransaction_INTERFACE_DEFINED__
+#define __ITipTransaction_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITipTransaction;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITipTransaction : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Push(char *i_pszRemoteTmUrl,char **o_ppszRemoteTxUrl) = 0;
+ virtual HRESULT WINAPI GetTransactionUrl(char **o_ppszLocalTxUrl) = 0;
+ };
+#else
+ typedef struct ITipTransactionVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITipTransaction *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITipTransaction *This);
+ ULONG (WINAPI *Release)(ITipTransaction *This);
+ HRESULT (WINAPI *Push)(ITipTransaction *This,char *i_pszRemoteTmUrl,char **o_ppszRemoteTxUrl);
+ HRESULT (WINAPI *GetTransactionUrl)(ITipTransaction *This,char **o_ppszLocalTxUrl);
+ END_INTERFACE
+ } ITipTransactionVtbl;
+ struct ITipTransaction {
+ CONST_VTBL struct ITipTransactionVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITipTransaction_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITipTransaction_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITipTransaction_Release(This) (This)->lpVtbl->Release(This)
+#define ITipTransaction_Push(This,i_pszRemoteTmUrl,o_ppszRemoteTxUrl) (This)->lpVtbl->Push(This,i_pszRemoteTmUrl,o_ppszRemoteTxUrl)
+#define ITipTransaction_GetTransactionUrl(This,o_ppszLocalTxUrl) (This)->lpVtbl->GetTransactionUrl(This,o_ppszLocalTxUrl)
+#endif
+#endif
+ HRESULT WINAPI ITipTransaction_Push_Proxy(ITipTransaction *This,char *i_pszRemoteTmUrl,char **o_ppszRemoteTxUrl);
+ void __RPC_STUB ITipTransaction_Push_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITipTransaction_GetTransactionUrl_Proxy(ITipTransaction *This,char **o_ppszLocalTxUrl);
+ void __RPC_STUB ITipTransaction_GetTransactionUrl_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITipHelper_INTERFACE_DEFINED__
+#define __ITipHelper_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITipHelper;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITipHelper : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Pull(char *i_pszTxUrl,ITransaction **o_ppITransaction) = 0;
+ virtual HRESULT WINAPI PullAsync(char *i_pszTxUrl,ITipPullSink *i_pTipPullSink,ITransaction **o_ppITransaction) = 0;
+ virtual HRESULT WINAPI GetLocalTmUrl(char **o_ppszLocalTmUrl) = 0;
+ };
+#else
+ typedef struct ITipHelperVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITipHelper *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITipHelper *This);
+ ULONG (WINAPI *Release)(ITipHelper *This);
+ HRESULT (WINAPI *Pull)(ITipHelper *This,char *i_pszTxUrl,ITransaction **o_ppITransaction);
+ HRESULT (WINAPI *PullAsync)(ITipHelper *This,char *i_pszTxUrl,ITipPullSink *i_pTipPullSink,ITransaction **o_ppITransaction);
+ HRESULT (WINAPI *GetLocalTmUrl)(ITipHelper *This,char **o_ppszLocalTmUrl);
+ END_INTERFACE
+ } ITipHelperVtbl;
+ struct ITipHelper {
+ CONST_VTBL struct ITipHelperVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITipHelper_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITipHelper_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITipHelper_Release(This) (This)->lpVtbl->Release(This)
+#define ITipHelper_Pull(This,i_pszTxUrl,o_ppITransaction) (This)->lpVtbl->Pull(This,i_pszTxUrl,o_ppITransaction)
+#define ITipHelper_PullAsync(This,i_pszTxUrl,i_pTipPullSink,o_ppITransaction) (This)->lpVtbl->PullAsync(This,i_pszTxUrl,i_pTipPullSink,o_ppITransaction)
+#define ITipHelper_GetLocalTmUrl(This,o_ppszLocalTmUrl) (This)->lpVtbl->GetLocalTmUrl(This,o_ppszLocalTmUrl)
+#endif
+#endif
+ HRESULT WINAPI ITipHelper_Pull_Proxy(ITipHelper *This,char *i_pszTxUrl,ITransaction **o_ppITransaction);
+ void __RPC_STUB ITipHelper_Pull_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITipHelper_PullAsync_Proxy(ITipHelper *This,char *i_pszTxUrl,ITipPullSink *i_pTipPullSink,ITransaction **o_ppITransaction);
+ void __RPC_STUB ITipHelper_PullAsync_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITipHelper_GetLocalTmUrl_Proxy(ITipHelper *This,char **o_ppszLocalTmUrl);
+ void __RPC_STUB ITipHelper_GetLocalTmUrl_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITipPullSink_INTERFACE_DEFINED__
+#define __ITipPullSink_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITipPullSink;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITipPullSink : public IUnknown {
+ public:
+ virtual HRESULT WINAPI PullComplete(HRESULT i_hrPull) = 0;
+ };
+#else
+ typedef struct ITipPullSinkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITipPullSink *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITipPullSink *This);
+ ULONG (WINAPI *Release)(ITipPullSink *This);
+ HRESULT (WINAPI *PullComplete)(ITipPullSink *This,HRESULT i_hrPull);
+ END_INTERFACE
+ } ITipPullSinkVtbl;
+ struct ITipPullSink {
+ CONST_VTBL struct ITipPullSinkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITipPullSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITipPullSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITipPullSink_Release(This) (This)->lpVtbl->Release(This)
+#define ITipPullSink_PullComplete(This,i_hrPull) (This)->lpVtbl->PullComplete(This,i_hrPull)
+#endif
+#endif
+ HRESULT WINAPI ITipPullSink_PullComplete_Proxy(ITipPullSink *This,HRESULT i_hrPull);
+ void __RPC_STUB ITipPullSink_PullComplete_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcNetworkAccessConfig_INTERFACE_DEFINED__
+#define __IDtcNetworkAccessConfig_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcNetworkAccessConfig;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcNetworkAccessConfig : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetAnyNetworkAccess(BOOL *pbAnyNetworkAccess) = 0;
+ virtual HRESULT WINAPI SetAnyNetworkAccess(BOOL bAnyNetworkAccess) = 0;
+ virtual HRESULT WINAPI GetNetworkAdministrationAccess(BOOL *pbNetworkAdministrationAccess) = 0;
+ virtual HRESULT WINAPI SetNetworkAdministrationAccess(BOOL bNetworkAdministrationAccess) = 0;
+ virtual HRESULT WINAPI GetNetworkTransactionAccess(BOOL *pbNetworkTransactionAccess) = 0;
+ virtual HRESULT WINAPI SetNetworkTransactionAccess(BOOL bNetworkTransactionAccess) = 0;
+ virtual HRESULT WINAPI GetNetworkClientAccess(BOOL *pbNetworkClientAccess) = 0;
+ virtual HRESULT WINAPI SetNetworkClientAccess(BOOL bNetworkClientAccess) = 0;
+ virtual HRESULT WINAPI GetNetworkTIPAccess(BOOL *pbNetworkTIPAccess) = 0;
+ virtual HRESULT WINAPI SetNetworkTIPAccess(BOOL bNetworkTIPAccess) = 0;
+ virtual HRESULT WINAPI GetXAAccess(BOOL *pbXAAccess) = 0;
+ virtual HRESULT WINAPI SetXAAccess(BOOL bXAAccess) = 0;
+ virtual HRESULT WINAPI RestartDtcService(void) = 0;
+ };
+#else
+ typedef struct IDtcNetworkAccessConfigVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcNetworkAccessConfig *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcNetworkAccessConfig *This);
+ ULONG (WINAPI *Release)(IDtcNetworkAccessConfig *This);
+ HRESULT (WINAPI *GetAnyNetworkAccess)(IDtcNetworkAccessConfig *This,BOOL *pbAnyNetworkAccess);
+ HRESULT (WINAPI *SetAnyNetworkAccess)(IDtcNetworkAccessConfig *This,BOOL bAnyNetworkAccess);
+ HRESULT (WINAPI *GetNetworkAdministrationAccess)(IDtcNetworkAccessConfig *This,BOOL *pbNetworkAdministrationAccess);
+ HRESULT (WINAPI *SetNetworkAdministrationAccess)(IDtcNetworkAccessConfig *This,BOOL bNetworkAdministrationAccess);
+ HRESULT (WINAPI *GetNetworkTransactionAccess)(IDtcNetworkAccessConfig *This,BOOL *pbNetworkTransactionAccess);
+ HRESULT (WINAPI *SetNetworkTransactionAccess)(IDtcNetworkAccessConfig *This,BOOL bNetworkTransactionAccess);
+ HRESULT (WINAPI *GetNetworkClientAccess)(IDtcNetworkAccessConfig *This,BOOL *pbNetworkClientAccess);
+ HRESULT (WINAPI *SetNetworkClientAccess)(IDtcNetworkAccessConfig *This,BOOL bNetworkClientAccess);
+ HRESULT (WINAPI *GetNetworkTIPAccess)(IDtcNetworkAccessConfig *This,BOOL *pbNetworkTIPAccess);
+ HRESULT (WINAPI *SetNetworkTIPAccess)(IDtcNetworkAccessConfig *This,BOOL bNetworkTIPAccess);
+ HRESULT (WINAPI *GetXAAccess)(IDtcNetworkAccessConfig *This,BOOL *pbXAAccess);
+ HRESULT (WINAPI *SetXAAccess)(IDtcNetworkAccessConfig *This,BOOL bXAAccess);
+ HRESULT (WINAPI *RestartDtcService)(IDtcNetworkAccessConfig *This);
+ END_INTERFACE
+ } IDtcNetworkAccessConfigVtbl;
+ struct IDtcNetworkAccessConfig {
+ CONST_VTBL struct IDtcNetworkAccessConfigVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcNetworkAccessConfig_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcNetworkAccessConfig_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcNetworkAccessConfig_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcNetworkAccessConfig_GetAnyNetworkAccess(This,pbAnyNetworkAccess) (This)->lpVtbl->GetAnyNetworkAccess(This,pbAnyNetworkAccess)
+#define IDtcNetworkAccessConfig_SetAnyNetworkAccess(This,bAnyNetworkAccess) (This)->lpVtbl->SetAnyNetworkAccess(This,bAnyNetworkAccess)
+#define IDtcNetworkAccessConfig_GetNetworkAdministrationAccess(This,pbNetworkAdministrationAccess) (This)->lpVtbl->GetNetworkAdministrationAccess(This,pbNetworkAdministrationAccess)
+#define IDtcNetworkAccessConfig_SetNetworkAdministrationAccess(This,bNetworkAdministrationAccess) (This)->lpVtbl->SetNetworkAdministrationAccess(This,bNetworkAdministrationAccess)
+#define IDtcNetworkAccessConfig_GetNetworkTransactionAccess(This,pbNetworkTransactionAccess) (This)->lpVtbl->GetNetworkTransactionAccess(This,pbNetworkTransactionAccess)
+#define IDtcNetworkAccessConfig_SetNetworkTransactionAccess(This,bNetworkTransactionAccess) (This)->lpVtbl->SetNetworkTransactionAccess(This,bNetworkTransactionAccess)
+#define IDtcNetworkAccessConfig_GetNetworkClientAccess(This,pbNetworkClientAccess) (This)->lpVtbl->GetNetworkClientAccess(This,pbNetworkClientAccess)
+#define IDtcNetworkAccessConfig_SetNetworkClientAccess(This,bNetworkClientAccess) (This)->lpVtbl->SetNetworkClientAccess(This,bNetworkClientAccess)
+#define IDtcNetworkAccessConfig_GetNetworkTIPAccess(This,pbNetworkTIPAccess) (This)->lpVtbl->GetNetworkTIPAccess(This,pbNetworkTIPAccess)
+#define IDtcNetworkAccessConfig_SetNetworkTIPAccess(This,bNetworkTIPAccess) (This)->lpVtbl->SetNetworkTIPAccess(This,bNetworkTIPAccess)
+#define IDtcNetworkAccessConfig_GetXAAccess(This,pbXAAccess) (This)->lpVtbl->GetXAAccess(This,pbXAAccess)
+#define IDtcNetworkAccessConfig_SetXAAccess(This,bXAAccess) (This)->lpVtbl->SetXAAccess(This,bXAAccess)
+#define IDtcNetworkAccessConfig_RestartDtcService(This) (This)->lpVtbl->RestartDtcService(This)
+#endif
+#endif
+ HRESULT WINAPI IDtcNetworkAccessConfig_GetAnyNetworkAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL *pbAnyNetworkAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_GetAnyNetworkAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_SetAnyNetworkAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL bAnyNetworkAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_SetAnyNetworkAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_GetNetworkAdministrationAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL *pbNetworkAdministrationAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_GetNetworkAdministrationAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_SetNetworkAdministrationAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL bNetworkAdministrationAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_SetNetworkAdministrationAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_GetNetworkTransactionAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL *pbNetworkTransactionAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_GetNetworkTransactionAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_SetNetworkTransactionAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL bNetworkTransactionAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_SetNetworkTransactionAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_GetNetworkClientAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL *pbNetworkClientAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_GetNetworkClientAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_SetNetworkClientAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL bNetworkClientAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_SetNetworkClientAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_GetNetworkTIPAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL *pbNetworkTIPAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_GetNetworkTIPAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_SetNetworkTIPAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL bNetworkTIPAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_SetNetworkTIPAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_GetXAAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL *pbXAAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_GetXAAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_SetXAAccess_Proxy(IDtcNetworkAccessConfig *This,BOOL bXAAccess);
+ void __RPC_STUB IDtcNetworkAccessConfig_SetXAAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig_RestartDtcService_Proxy(IDtcNetworkAccessConfig *This);
+ void __RPC_STUB IDtcNetworkAccessConfig_RestartDtcService_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+ typedef enum AUTHENTICATION_LEVEL {
+ NO_AUTHENTICATION_REQUIRED = 0,INCOMING_AUTHENTICATION_REQUIRED = 1,MUTUAL_AUTHENTICATION_REQUIRED = 2
+ } AUTHENTICATION_LEVEL;
+
+ extern RPC_IF_HANDLE __MIDL_itf_txcoord_0115_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txcoord_0115_v0_0_s_ifspec;
+
+#ifndef __IDtcNetworkAccessConfig2_INTERFACE_DEFINED__
+#define __IDtcNetworkAccessConfig2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcNetworkAccessConfig2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcNetworkAccessConfig2 : public IDtcNetworkAccessConfig {
+ public:
+ virtual HRESULT WINAPI GetNetworkInboundAccess(BOOL *pbInbound) = 0;
+ virtual HRESULT WINAPI GetNetworkOutboundAccess(BOOL *pbOutbound) = 0;
+ virtual HRESULT WINAPI SetNetworkInboundAccess(BOOL bInbound) = 0;
+ virtual HRESULT WINAPI SetNetworkOutboundAccess(BOOL bOutbound) = 0;
+ virtual HRESULT WINAPI GetAuthenticationLevel(AUTHENTICATION_LEVEL *pAuthLevel) = 0;
+ virtual HRESULT WINAPI SetAuthenticationLevel(AUTHENTICATION_LEVEL AuthLevel) = 0;
+ };
+#else
+ typedef struct IDtcNetworkAccessConfig2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcNetworkAccessConfig2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcNetworkAccessConfig2 *This);
+ ULONG (WINAPI *Release)(IDtcNetworkAccessConfig2 *This);
+ HRESULT (WINAPI *GetAnyNetworkAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbAnyNetworkAccess);
+ HRESULT (WINAPI *SetAnyNetworkAccess)(IDtcNetworkAccessConfig2 *This,BOOL bAnyNetworkAccess);
+ HRESULT (WINAPI *GetNetworkAdministrationAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbNetworkAdministrationAccess);
+ HRESULT (WINAPI *SetNetworkAdministrationAccess)(IDtcNetworkAccessConfig2 *This,BOOL bNetworkAdministrationAccess);
+ HRESULT (WINAPI *GetNetworkTransactionAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbNetworkTransactionAccess);
+ HRESULT (WINAPI *SetNetworkTransactionAccess)(IDtcNetworkAccessConfig2 *This,BOOL bNetworkTransactionAccess);
+ HRESULT (WINAPI *GetNetworkClientAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbNetworkClientAccess);
+ HRESULT (WINAPI *SetNetworkClientAccess)(IDtcNetworkAccessConfig2 *This,BOOL bNetworkClientAccess);
+ HRESULT (WINAPI *GetNetworkTIPAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbNetworkTIPAccess);
+ HRESULT (WINAPI *SetNetworkTIPAccess)(IDtcNetworkAccessConfig2 *This,BOOL bNetworkTIPAccess);
+ HRESULT (WINAPI *GetXAAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbXAAccess);
+ HRESULT (WINAPI *SetXAAccess)(IDtcNetworkAccessConfig2 *This,BOOL bXAAccess);
+ HRESULT (WINAPI *RestartDtcService)(IDtcNetworkAccessConfig2 *This);
+ HRESULT (WINAPI *GetNetworkInboundAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbInbound);
+ HRESULT (WINAPI *GetNetworkOutboundAccess)(IDtcNetworkAccessConfig2 *This,BOOL *pbOutbound);
+ HRESULT (WINAPI *SetNetworkInboundAccess)(IDtcNetworkAccessConfig2 *This,BOOL bInbound);
+ HRESULT (WINAPI *SetNetworkOutboundAccess)(IDtcNetworkAccessConfig2 *This,BOOL bOutbound);
+ HRESULT (WINAPI *GetAuthenticationLevel)(IDtcNetworkAccessConfig2 *This,AUTHENTICATION_LEVEL *pAuthLevel);
+ HRESULT (WINAPI *SetAuthenticationLevel)(IDtcNetworkAccessConfig2 *This,AUTHENTICATION_LEVEL AuthLevel);
+ END_INTERFACE
+ } IDtcNetworkAccessConfig2Vtbl;
+ struct IDtcNetworkAccessConfig2 {
+ CONST_VTBL struct IDtcNetworkAccessConfig2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcNetworkAccessConfig2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcNetworkAccessConfig2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcNetworkAccessConfig2_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcNetworkAccessConfig2_GetAnyNetworkAccess(This,pbAnyNetworkAccess) (This)->lpVtbl->GetAnyNetworkAccess(This,pbAnyNetworkAccess)
+#define IDtcNetworkAccessConfig2_SetAnyNetworkAccess(This,bAnyNetworkAccess) (This)->lpVtbl->SetAnyNetworkAccess(This,bAnyNetworkAccess)
+#define IDtcNetworkAccessConfig2_GetNetworkAdministrationAccess(This,pbNetworkAdministrationAccess) (This)->lpVtbl->GetNetworkAdministrationAccess(This,pbNetworkAdministrationAccess)
+#define IDtcNetworkAccessConfig2_SetNetworkAdministrationAccess(This,bNetworkAdministrationAccess) (This)->lpVtbl->SetNetworkAdministrationAccess(This,bNetworkAdministrationAccess)
+#define IDtcNetworkAccessConfig2_GetNetworkTransactionAccess(This,pbNetworkTransactionAccess) (This)->lpVtbl->GetNetworkTransactionAccess(This,pbNetworkTransactionAccess)
+#define IDtcNetworkAccessConfig2_SetNetworkTransactionAccess(This,bNetworkTransactionAccess) (This)->lpVtbl->SetNetworkTransactionAccess(This,bNetworkTransactionAccess)
+#define IDtcNetworkAccessConfig2_GetNetworkClientAccess(This,pbNetworkClientAccess) (This)->lpVtbl->GetNetworkClientAccess(This,pbNetworkClientAccess)
+#define IDtcNetworkAccessConfig2_SetNetworkClientAccess(This,bNetworkClientAccess) (This)->lpVtbl->SetNetworkClientAccess(This,bNetworkClientAccess)
+#define IDtcNetworkAccessConfig2_GetNetworkTIPAccess(This,pbNetworkTIPAccess) (This)->lpVtbl->GetNetworkTIPAccess(This,pbNetworkTIPAccess)
+#define IDtcNetworkAccessConfig2_SetNetworkTIPAccess(This,bNetworkTIPAccess) (This)->lpVtbl->SetNetworkTIPAccess(This,bNetworkTIPAccess)
+#define IDtcNetworkAccessConfig2_GetXAAccess(This,pbXAAccess) (This)->lpVtbl->GetXAAccess(This,pbXAAccess)
+#define IDtcNetworkAccessConfig2_SetXAAccess(This,bXAAccess) (This)->lpVtbl->SetXAAccess(This,bXAAccess)
+#define IDtcNetworkAccessConfig2_RestartDtcService(This) (This)->lpVtbl->RestartDtcService(This)
+#define IDtcNetworkAccessConfig2_GetNetworkInboundAccess(This,pbInbound) (This)->lpVtbl->GetNetworkInboundAccess(This,pbInbound)
+#define IDtcNetworkAccessConfig2_GetNetworkOutboundAccess(This,pbOutbound) (This)->lpVtbl->GetNetworkOutboundAccess(This,pbOutbound)
+#define IDtcNetworkAccessConfig2_SetNetworkInboundAccess(This,bInbound) (This)->lpVtbl->SetNetworkInboundAccess(This,bInbound)
+#define IDtcNetworkAccessConfig2_SetNetworkOutboundAccess(This,bOutbound) (This)->lpVtbl->SetNetworkOutboundAccess(This,bOutbound)
+#define IDtcNetworkAccessConfig2_GetAuthenticationLevel(This,pAuthLevel) (This)->lpVtbl->GetAuthenticationLevel(This,pAuthLevel)
+#define IDtcNetworkAccessConfig2_SetAuthenticationLevel(This,AuthLevel) (This)->lpVtbl->SetAuthenticationLevel(This,AuthLevel)
+#endif
+#endif
+ HRESULT WINAPI IDtcNetworkAccessConfig2_GetNetworkInboundAccess_Proxy(IDtcNetworkAccessConfig2 *This,BOOL *pbInbound);
+ void __RPC_STUB IDtcNetworkAccessConfig2_GetNetworkInboundAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig2_GetNetworkOutboundAccess_Proxy(IDtcNetworkAccessConfig2 *This,BOOL *pbOutbound);
+ void __RPC_STUB IDtcNetworkAccessConfig2_GetNetworkOutboundAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig2_SetNetworkInboundAccess_Proxy(IDtcNetworkAccessConfig2 *This,BOOL bInbound);
+ void __RPC_STUB IDtcNetworkAccessConfig2_SetNetworkInboundAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig2_SetNetworkOutboundAccess_Proxy(IDtcNetworkAccessConfig2 *This,BOOL bOutbound);
+ void __RPC_STUB IDtcNetworkAccessConfig2_SetNetworkOutboundAccess_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig2_GetAuthenticationLevel_Proxy(IDtcNetworkAccessConfig2 *This,AUTHENTICATION_LEVEL *pAuthLevel);
+ void __RPC_STUB IDtcNetworkAccessConfig2_GetAuthenticationLevel_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcNetworkAccessConfig2_SetAuthenticationLevel_Proxy(IDtcNetworkAccessConfig2 *This,AUTHENTICATION_LEVEL AuthLevel);
+ void __RPC_STUB IDtcNetworkAccessConfig2_SetAuthenticationLevel_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+ DEFINE_GUID(IID_ITransactionResourceAsync,0x69E971F0,0x23CE,0x11cf,0xAD,0x60,0x00,0xAA,0x00,0xA7,0x4C,0xCD);
+ DEFINE_GUID(IID_ITransactionLastResourceAsync,0xC82BD532,0x5B30,0x11D3,0x8A,0x91,0x00,0xC0,0x4F,0x79,0xEB,0x6D);
+ DEFINE_GUID(IID_ITransactionResource,0xEE5FF7B3,0x4572,0x11d0,0x94,0x52,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_ITransactionEnlistmentAsync,0x0fb15081,0xaf41,0x11ce,0xbd,0x2b,0x20,0x4c,0x4f,0x4f,0x50,0x20);
+ DEFINE_GUID(IID_ITransactionLastEnlistmentAsync,0xC82BD533,0x5B30,0x11D3,0x8A,0x91,0x00,0xC0,0x4F,0x79,0xEB,0x6D);
+ DEFINE_GUID(IID_ITransactionExportFactory,0xE1CF9B53,0x8745,0x11ce,0xA9,0xBA,0x00,0xAA,0x00,0x6C,0x37,0x06);
+ DEFINE_GUID(IID_ITransactionImportWhereabouts,0x0141fda4,0x8fc0,0x11ce,0xbd,0x18,0x20,0x4c,0x4f,0x4f,0x50,0x20);
+ DEFINE_GUID(IID_ITransactionExport,0x0141fda5,0x8fc0,0x11ce,0xbd,0x18,0x20,0x4c,0x4f,0x4f,0x50,0x20);
+ DEFINE_GUID(IID_ITransactionImport,0xE1CF9B5A,0x8745,0x11ce,0xA9,0xBA,0x00,0xAA,0x00,0x6C,0x37,0x06);
+ DEFINE_GUID(IID_ITipTransaction,0x17cf72d0,0xbac5,0x11d1,0xb1,0xbf,0x0,0xc0,0x4f,0xc2,0xf3,0xef);
+ DEFINE_GUID(IID_ITipHelper,0x17cf72d1,0xbac5,0x11d1,0xb1,0xbf,0x0,0xc0,0x4f,0xc2,0xf3,0xef);
+ DEFINE_GUID(IID_ITipPullSink,0x17cf72d2,0xbac5,0x11d1,0xb1,0xbf,0x0,0xc0,0x4f,0xc2,0xf3,0xef);
+ DEFINE_GUID(IID_IDtcNetworkAccessConfig,0x9797c15d,0xa428,0x4291,0x87,0xb6,0x9,0x95,0x3,0x1a,0x67,0x8d);
+ DEFINE_GUID(IID_IDtcNetworkAccessConfig2,0xa7aa013b,0xeb7d,0x4f42,0xb4,0x1c,0xb2,0xde,0xc0,0x9a,0xe0,0x34);
+
+ extern RPC_IF_HANDLE __MIDL_itf_txcoord_0116_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txcoord_0116_v0_0_s_ifspec;
+
+ HRESULT WINAPI ITransactionImportWhereabouts_GetWhereabouts_Proxy(ITransactionImportWhereabouts *This,ULONG cbWhereabouts,byte *rgbWhereabouts,ULONG *pcbUsed);
+ HRESULT WINAPI ITransactionImportWhereabouts_GetWhereabouts_Stub(ITransactionImportWhereabouts *This,ULONG *pcbUsed,ULONG cbWhereabouts,byte *rgbWhereabouts);
+ HRESULT WINAPI ITransactionExport_GetTransactionCookie_Proxy(ITransactionExport *This,IUnknown *punkTransaction,ULONG cbTransactionCookie,byte *rgbTransactionCookie,ULONG *pcbUsed);
+ HRESULT WINAPI ITransactionExport_GetTransactionCookie_Stub(ITransactionExport *This,IUnknown *punkTransaction,ULONG *pcbUsed,ULONG cbTransactionCookie,byte *rgbTransactionCookie);
+
+#ifdef __cplusplus
+}
+#endif
+#endif
diff --git a/include/txdtc.h b/include/txdtc.h
new file mode 100644
index 0000000..0b28b8c
--- /dev/null
+++ b/include/txdtc.h
@@ -0,0 +1,1887 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is derived from the mingw-w64 runtime package.
+ */
+#ifndef __REQUIRED_RPCNDR_H_VERSION__
+#define __REQUIRED_RPCNDR_H_VERSION__ 475
+#endif
+
+#include "rpc.h"
+#include "rpcndr.h"
+
+#ifndef __RPCNDR_H_VERSION__
+#error This stub requires an updated version of <rpcndr.h>
+#endif
+
+#ifndef COM_NO_WINDOWS_H
+#include "windows.h"
+#include "ole2.h"
+#endif
+
+#ifndef __txdtc_h__
+#define __txdtc_h__
+
+#ifndef __IXATransLookup_FWD_DEFINED__
+#define __IXATransLookup_FWD_DEFINED__
+typedef struct IXATransLookup IXATransLookup;
+#endif
+
+#ifndef __IXATransLookup2_FWD_DEFINED__
+#define __IXATransLookup2_FWD_DEFINED__
+typedef struct IXATransLookup2 IXATransLookup2;
+#endif
+
+#ifndef __IResourceManagerSink_FWD_DEFINED__
+#define __IResourceManagerSink_FWD_DEFINED__
+typedef struct IResourceManagerSink IResourceManagerSink;
+#endif
+
+#ifndef __IResourceManager_FWD_DEFINED__
+#define __IResourceManager_FWD_DEFINED__
+typedef struct IResourceManager IResourceManager;
+#endif
+
+#ifndef __ILastResourceManager_FWD_DEFINED__
+#define __ILastResourceManager_FWD_DEFINED__
+typedef struct ILastResourceManager ILastResourceManager;
+#endif
+
+#ifndef __IResourceManager2_FWD_DEFINED__
+#define __IResourceManager2_FWD_DEFINED__
+typedef struct IResourceManager2 IResourceManager2;
+#endif
+
+#ifndef __IXAConfig_FWD_DEFINED__
+#define __IXAConfig_FWD_DEFINED__
+typedef struct IXAConfig IXAConfig;
+#endif
+
+#ifndef __IRMHelper_FWD_DEFINED__
+#define __IRMHelper_FWD_DEFINED__
+typedef struct IRMHelper IRMHelper;
+#endif
+
+#ifndef __IXAObtainRMInfo_FWD_DEFINED__
+#define __IXAObtainRMInfo_FWD_DEFINED__
+typedef struct IXAObtainRMInfo IXAObtainRMInfo;
+#endif
+
+#ifndef __IResourceManagerFactory_FWD_DEFINED__
+#define __IResourceManagerFactory_FWD_DEFINED__
+typedef struct IResourceManagerFactory IResourceManagerFactory;
+#endif
+
+#ifndef __IResourceManagerFactory2_FWD_DEFINED__
+#define __IResourceManagerFactory2_FWD_DEFINED__
+typedef struct IResourceManagerFactory2 IResourceManagerFactory2;
+#endif
+
+#ifndef __IPrepareInfo_FWD_DEFINED__
+#define __IPrepareInfo_FWD_DEFINED__
+typedef struct IPrepareInfo IPrepareInfo;
+#endif
+
+#ifndef __IPrepareInfo2_FWD_DEFINED__
+#define __IPrepareInfo2_FWD_DEFINED__
+typedef struct IPrepareInfo2 IPrepareInfo2;
+#endif
+
+#ifndef __IGetDispenser_FWD_DEFINED__
+#define __IGetDispenser_FWD_DEFINED__
+typedef struct IGetDispenser IGetDispenser;
+#endif
+
+#ifndef __ITransactionVoterBallotAsync2_FWD_DEFINED__
+#define __ITransactionVoterBallotAsync2_FWD_DEFINED__
+typedef struct ITransactionVoterBallotAsync2 ITransactionVoterBallotAsync2;
+#endif
+
+#ifndef __ITransactionVoterNotifyAsync2_FWD_DEFINED__
+#define __ITransactionVoterNotifyAsync2_FWD_DEFINED__
+typedef struct ITransactionVoterNotifyAsync2 ITransactionVoterNotifyAsync2;
+#endif
+
+#ifndef __ITransactionVoterFactory2_FWD_DEFINED__
+#define __ITransactionVoterFactory2_FWD_DEFINED__
+typedef struct ITransactionVoterFactory2 ITransactionVoterFactory2;
+#endif
+
+#ifndef __ITransactionPhase0EnlistmentAsync_FWD_DEFINED__
+#define __ITransactionPhase0EnlistmentAsync_FWD_DEFINED__
+typedef struct ITransactionPhase0EnlistmentAsync ITransactionPhase0EnlistmentAsync;
+#endif
+
+#ifndef __ITransactionPhase0NotifyAsync_FWD_DEFINED__
+#define __ITransactionPhase0NotifyAsync_FWD_DEFINED__
+typedef struct ITransactionPhase0NotifyAsync ITransactionPhase0NotifyAsync;
+#endif
+
+#ifndef __ITransactionPhase0Factory_FWD_DEFINED__
+#define __ITransactionPhase0Factory_FWD_DEFINED__
+typedef struct ITransactionPhase0Factory ITransactionPhase0Factory;
+#endif
+
+#ifndef __ITransactionTransmitter_FWD_DEFINED__
+#define __ITransactionTransmitter_FWD_DEFINED__
+typedef struct ITransactionTransmitter ITransactionTransmitter;
+#endif
+
+#ifndef __ITransactionTransmitterFactory_FWD_DEFINED__
+#define __ITransactionTransmitterFactory_FWD_DEFINED__
+typedef struct ITransactionTransmitterFactory ITransactionTransmitterFactory;
+#endif
+
+#ifndef __ITransactionReceiver_FWD_DEFINED__
+#define __ITransactionReceiver_FWD_DEFINED__
+typedef struct ITransactionReceiver ITransactionReceiver;
+#endif
+
+#ifndef __ITransactionReceiverFactory_FWD_DEFINED__
+#define __ITransactionReceiverFactory_FWD_DEFINED__
+typedef struct ITransactionReceiverFactory ITransactionReceiverFactory;
+#endif
+
+#ifndef __IDtcLuConfigure_FWD_DEFINED__
+#define __IDtcLuConfigure_FWD_DEFINED__
+typedef struct IDtcLuConfigure IDtcLuConfigure;
+#endif
+
+#ifndef __IDtcLuRecovery_FWD_DEFINED__
+#define __IDtcLuRecovery_FWD_DEFINED__
+typedef struct IDtcLuRecovery IDtcLuRecovery;
+#endif
+
+#ifndef __IDtcLuRecoveryFactory_FWD_DEFINED__
+#define __IDtcLuRecoveryFactory_FWD_DEFINED__
+typedef struct IDtcLuRecoveryFactory IDtcLuRecoveryFactory;
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByDtcTransWork_FWD_DEFINED__
+#define __IDtcLuRecoveryInitiatedByDtcTransWork_FWD_DEFINED__
+typedef struct IDtcLuRecoveryInitiatedByDtcTransWork IDtcLuRecoveryInitiatedByDtcTransWork;
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByDtcStatusWork_FWD_DEFINED__
+#define __IDtcLuRecoveryInitiatedByDtcStatusWork_FWD_DEFINED__
+typedef struct IDtcLuRecoveryInitiatedByDtcStatusWork IDtcLuRecoveryInitiatedByDtcStatusWork;
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByDtc_FWD_DEFINED__
+#define __IDtcLuRecoveryInitiatedByDtc_FWD_DEFINED__
+typedef struct IDtcLuRecoveryInitiatedByDtc IDtcLuRecoveryInitiatedByDtc;
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByLuWork_FWD_DEFINED__
+#define __IDtcLuRecoveryInitiatedByLuWork_FWD_DEFINED__
+typedef struct IDtcLuRecoveryInitiatedByLuWork IDtcLuRecoveryInitiatedByLuWork;
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByLu_FWD_DEFINED__
+#define __IDtcLuRecoveryInitiatedByLu_FWD_DEFINED__
+typedef struct IDtcLuRecoveryInitiatedByLu IDtcLuRecoveryInitiatedByLu;
+#endif
+
+#ifndef __IDtcLuRmEnlistment_FWD_DEFINED__
+#define __IDtcLuRmEnlistment_FWD_DEFINED__
+typedef struct IDtcLuRmEnlistment IDtcLuRmEnlistment;
+#endif
+
+#ifndef __IDtcLuRmEnlistmentSink_FWD_DEFINED__
+#define __IDtcLuRmEnlistmentSink_FWD_DEFINED__
+typedef struct IDtcLuRmEnlistmentSink IDtcLuRmEnlistmentSink;
+#endif
+
+#ifndef __IDtcLuRmEnlistmentFactory_FWD_DEFINED__
+#define __IDtcLuRmEnlistmentFactory_FWD_DEFINED__
+typedef struct IDtcLuRmEnlistmentFactory IDtcLuRmEnlistmentFactory;
+#endif
+
+#ifndef __IDtcLuSubordinateDtc_FWD_DEFINED__
+#define __IDtcLuSubordinateDtc_FWD_DEFINED__
+typedef struct IDtcLuSubordinateDtc IDtcLuSubordinateDtc;
+#endif
+
+#ifndef __IDtcLuSubordinateDtcSink_FWD_DEFINED__
+#define __IDtcLuSubordinateDtcSink_FWD_DEFINED__
+typedef struct IDtcLuSubordinateDtcSink IDtcLuSubordinateDtcSink;
+#endif
+
+#ifndef __IDtcLuSubordinateDtcFactory_FWD_DEFINED__
+#define __IDtcLuSubordinateDtcFactory_FWD_DEFINED__
+typedef struct IDtcLuSubordinateDtcFactory IDtcLuSubordinateDtcFactory;
+#endif
+
+#include "txcoord.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define XACTTOMSG(dwXact) (dwXact-0x00040000+0x40000000)
+ typedef enum XACT_DTC_CONSTANTS {
+ XACT_E_CONNECTION_REQUEST_DENIED = 0x8004d100,XACT_E_TOOMANY_ENLISTMENTS = 0x8004d101,XACT_E_DUPLICATE_GUID = 0x8004d102,
+ XACT_E_NOTSINGLEPHASE = 0x8004d103,XACT_E_RECOVERYALREADYDONE = 0x8004d104,XACT_E_PROTOCOL = 0x8004d105,XACT_E_RM_FAILURE = 0x8004d106,
+ XACT_E_RECOVERY_FAILED = 0x8004d107,XACT_E_LU_NOT_FOUND = 0x8004d108,XACT_E_DUPLICATE_LU = 0x8004d109,XACT_E_LU_NOT_CONNECTED = 0x8004d10a,
+ XACT_E_DUPLICATE_TRANSID = 0x8004d10b,XACT_E_LU_BUSY = 0x8004d10c,XACT_E_LU_NO_RECOVERY_PROCESS = 0x8004d10d,XACT_E_LU_DOWN = 0x8004d10e,
+ XACT_E_LU_RECOVERING = 0x8004d10f,XACT_E_LU_RECOVERY_MISMATCH = 0x8004d110,XACT_E_RM_UNAVAILABLE = 0x8004d111,
+ XACT_E_LRMRECOVERYALREADYDONE = 0x8004d112,XACT_E_NOLASTRESOURCEINTERFACE = 0x8004d113,XACT_S_NONOTIFY = 0x4d100,XACT_OK_NONOTIFY = 0x4d101,
+ dwUSER_MS_SQLSERVER = 0xffff
+ } XACT_DTC_CONSTANTS;
+
+#ifndef _XID_T_DEFINED
+#define _XID_T_DEFINED
+ typedef struct xid_t {
+ LONG32 formatID;
+ LONG32 gtrid_length;
+ LONG32 bqual_length;
+ char data[128 ];
+ } XID;
+#endif
+#ifndef _XA_SWITCH_T_DEFINED
+#define _XA_SWITCH_T_DEFINED
+ typedef struct xa_switch_t {
+ char name[32 ];
+ LONG32 flags;
+ LONG32 version;
+ int (__cdecl *xa_open_entry)(char *__MIDL_0004,int __MIDL_0005,LONG32 __MIDL_0006);
+ int (__cdecl *xa_close_entry)(char *__MIDL_0008,int __MIDL_0009,LONG32 __MIDL_0010);
+ int (__cdecl *xa_start_entry)(XID *__MIDL_0012,int __MIDL_0013,LONG32 __MIDL_0014);
+ int (__cdecl *xa_end_entry)(XID *__MIDL_0016,int __MIDL_0017,LONG32 __MIDL_0018);
+ int (__cdecl *xa_rollback_entry)(XID *__MIDL_0020,int __MIDL_0021,LONG32 __MIDL_0022);
+ int (__cdecl *xa_prepare_entry)(XID *__MIDL_0024,int __MIDL_0025,LONG32 __MIDL_0026);
+ int (__cdecl *xa_commit_entry)(XID *__MIDL_0028,int __MIDL_0029,LONG32 __MIDL_0030);
+ int (__cdecl *xa_recover_entry)(XID *__MIDL_0032,LONG32 __MIDL_0033,int __MIDL_0034,LONG32 __MIDL_0035);
+ int (__cdecl *xa_forget_entry)(XID *__MIDL_0037,int __MIDL_0038,LONG32 __MIDL_0039);
+ int (__cdecl *xa_complete_entry)(int *__MIDL_0041,int *__MIDL_0042,int __MIDL_0043,LONG32 __MIDL_0044);
+ } xa_switch_t;
+#endif
+
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0000_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0000_v0_0_s_ifspec;
+#ifndef __IXATransLookup_INTERFACE_DEFINED__
+#define __IXATransLookup_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IXATransLookup;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IXATransLookup : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Lookup(ITransaction **ppTransaction) = 0;
+ };
+#else
+ typedef struct IXATransLookupVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IXATransLookup *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IXATransLookup *This);
+ ULONG (WINAPI *Release)(IXATransLookup *This);
+ HRESULT (WINAPI *Lookup)(IXATransLookup *This,ITransaction **ppTransaction);
+ END_INTERFACE
+ } IXATransLookupVtbl;
+ struct IXATransLookup {
+ CONST_VTBL struct IXATransLookupVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IXATransLookup_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IXATransLookup_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IXATransLookup_Release(This) (This)->lpVtbl->Release(This)
+#define IXATransLookup_Lookup(This,ppTransaction) (This)->lpVtbl->Lookup(This,ppTransaction)
+#endif
+#endif
+ HRESULT WINAPI IXATransLookup_Lookup_Proxy(IXATransLookup *This,ITransaction **ppTransaction);
+ void __RPC_STUB IXATransLookup_Lookup_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IXATransLookup2_INTERFACE_DEFINED__
+#define __IXATransLookup2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IXATransLookup2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IXATransLookup2 : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Lookup(XID *pXID,ITransaction **ppTransaction) = 0;
+ };
+#else
+ typedef struct IXATransLookup2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IXATransLookup2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IXATransLookup2 *This);
+ ULONG (WINAPI *Release)(IXATransLookup2 *This);
+ HRESULT (WINAPI *Lookup)(IXATransLookup2 *This,XID *pXID,ITransaction **ppTransaction);
+ END_INTERFACE
+ } IXATransLookup2Vtbl;
+ struct IXATransLookup2 {
+ CONST_VTBL struct IXATransLookup2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IXATransLookup2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IXATransLookup2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IXATransLookup2_Release(This) (This)->lpVtbl->Release(This)
+#define IXATransLookup2_Lookup(This,pXID,ppTransaction) (This)->lpVtbl->Lookup(This,pXID,ppTransaction)
+#endif
+#endif
+ HRESULT WINAPI IXATransLookup2_Lookup_Proxy(IXATransLookup2 *This,XID *pXID,ITransaction **ppTransaction);
+ void __RPC_STUB IXATransLookup2_Lookup_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IResourceManagerSink_INTERFACE_DEFINED__
+#define __IResourceManagerSink_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IResourceManagerSink;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IResourceManagerSink : public IUnknown {
+ public:
+ virtual HRESULT WINAPI TMDown(void) = 0;
+ };
+#else
+ typedef struct IResourceManagerSinkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IResourceManagerSink *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IResourceManagerSink *This);
+ ULONG (WINAPI *Release)(IResourceManagerSink *This);
+ HRESULT (WINAPI *TMDown)(IResourceManagerSink *This);
+ END_INTERFACE
+ } IResourceManagerSinkVtbl;
+ struct IResourceManagerSink {
+ CONST_VTBL struct IResourceManagerSinkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IResourceManagerSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IResourceManagerSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IResourceManagerSink_Release(This) (This)->lpVtbl->Release(This)
+#define IResourceManagerSink_TMDown(This) (This)->lpVtbl->TMDown(This)
+#endif
+#endif
+ HRESULT WINAPI IResourceManagerSink_TMDown_Proxy(IResourceManagerSink *This);
+ void __RPC_STUB IResourceManagerSink_TMDown_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+#ifndef __IResourceManager_INTERFACE_DEFINED__
+#define __IResourceManager_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IResourceManager;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IResourceManager : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Enlist(ITransaction *pTransaction,ITransactionResourceAsync *pRes,XACTUOW *pUOW,LONG *pisoLevel,ITransactionEnlistmentAsync **ppEnlist) = 0;
+ virtual HRESULT WINAPI Reenlist(byte *pPrepInfo,ULONG cbPrepInfo,DWORD lTimeout,XACTSTAT *pXactStat) = 0;
+ virtual HRESULT WINAPI ReenlistmentComplete(void) = 0;
+ virtual HRESULT WINAPI GetDistributedTransactionManager(REFIID iid,void **ppvObject) = 0;
+ };
+#else
+ typedef struct IResourceManagerVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IResourceManager *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IResourceManager *This);
+ ULONG (WINAPI *Release)(IResourceManager *This);
+ HRESULT (WINAPI *Enlist)(IResourceManager *This,ITransaction *pTransaction,ITransactionResourceAsync *pRes,XACTUOW *pUOW,LONG *pisoLevel,ITransactionEnlistmentAsync **ppEnlist);
+ HRESULT (WINAPI *Reenlist)(IResourceManager *This,byte *pPrepInfo,ULONG cbPrepInfo,DWORD lTimeout,XACTSTAT *pXactStat);
+ HRESULT (WINAPI *ReenlistmentComplete)(IResourceManager *This);
+ HRESULT (WINAPI *GetDistributedTransactionManager)(IResourceManager *This,REFIID iid,void **ppvObject);
+ END_INTERFACE
+ } IResourceManagerVtbl;
+ struct IResourceManager {
+ CONST_VTBL struct IResourceManagerVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IResourceManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IResourceManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IResourceManager_Release(This) (This)->lpVtbl->Release(This)
+#define IResourceManager_Enlist(This,pTransaction,pRes,pUOW,pisoLevel,ppEnlist) (This)->lpVtbl->Enlist(This,pTransaction,pRes,pUOW,pisoLevel,ppEnlist)
+#define IResourceManager_Reenlist(This,pPrepInfo,cbPrepInfo,lTimeout,pXactStat) (This)->lpVtbl->Reenlist(This,pPrepInfo,cbPrepInfo,lTimeout,pXactStat)
+#define IResourceManager_ReenlistmentComplete(This) (This)->lpVtbl->ReenlistmentComplete(This)
+#define IResourceManager_GetDistributedTransactionManager(This,iid,ppvObject) (This)->lpVtbl->GetDistributedTransactionManager(This,iid,ppvObject)
+#endif
+#endif
+ HRESULT WINAPI IResourceManager_Enlist_Proxy(IResourceManager *This,ITransaction *pTransaction,ITransactionResourceAsync *pRes,XACTUOW *pUOW,LONG *pisoLevel,ITransactionEnlistmentAsync **ppEnlist);
+ void __RPC_STUB IResourceManager_Enlist_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IResourceManager_Reenlist_Proxy(IResourceManager *This,byte *pPrepInfo,ULONG cbPrepInfo,DWORD lTimeout,XACTSTAT *pXactStat);
+ void __RPC_STUB IResourceManager_Reenlist_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IResourceManager_ReenlistmentComplete_Proxy(IResourceManager *This);
+ void __RPC_STUB IResourceManager_ReenlistmentComplete_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IResourceManager_GetDistributedTransactionManager_Proxy(IResourceManager *This,REFIID iid,void **ppvObject);
+ void __RPC_STUB IResourceManager_GetDistributedTransactionManager_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ILastResourceManager_INTERFACE_DEFINED__
+#define __ILastResourceManager_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ILastResourceManager;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ILastResourceManager : public IUnknown {
+ public:
+ virtual HRESULT WINAPI TransactionCommitted(byte *pPrepInfo,ULONG cbPrepInfo) = 0;
+ virtual HRESULT WINAPI RecoveryDone(void) = 0;
+ };
+#else
+ typedef struct ILastResourceManagerVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ILastResourceManager *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ILastResourceManager *This);
+ ULONG (WINAPI *Release)(ILastResourceManager *This);
+ HRESULT (WINAPI *TransactionCommitted)(ILastResourceManager *This,byte *pPrepInfo,ULONG cbPrepInfo);
+ HRESULT (WINAPI *RecoveryDone)(ILastResourceManager *This);
+ END_INTERFACE
+ } ILastResourceManagerVtbl;
+ struct ILastResourceManager {
+ CONST_VTBL struct ILastResourceManagerVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ILastResourceManager_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ILastResourceManager_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ILastResourceManager_Release(This) (This)->lpVtbl->Release(This)
+#define ILastResourceManager_TransactionCommitted(This,pPrepInfo,cbPrepInfo) (This)->lpVtbl->TransactionCommitted(This,pPrepInfo,cbPrepInfo)
+#define ILastResourceManager_RecoveryDone(This) (This)->lpVtbl->RecoveryDone(This)
+#endif
+#endif
+ HRESULT WINAPI ILastResourceManager_TransactionCommitted_Proxy(ILastResourceManager *This,byte *pPrepInfo,ULONG cbPrepInfo);
+ void __RPC_STUB ILastResourceManager_TransactionCommitted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ILastResourceManager_RecoveryDone_Proxy(ILastResourceManager *This);
+ void __RPC_STUB ILastResourceManager_RecoveryDone_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IResourceManager2_INTERFACE_DEFINED__
+#define __IResourceManager2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IResourceManager2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IResourceManager2 : public IResourceManager {
+ public:
+ virtual HRESULT WINAPI Enlist2(ITransaction *pTransaction,ITransactionResourceAsync *pResAsync,XACTUOW *pUOW,LONG *pisoLevel,XID *pXid,ITransactionEnlistmentAsync **ppEnlist) = 0;
+ virtual HRESULT WINAPI Reenlist2(XID *pXid,DWORD dwTimeout,XACTSTAT *pXactStat) = 0;
+ };
+#else
+ typedef struct IResourceManager2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IResourceManager2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IResourceManager2 *This);
+ ULONG (WINAPI *Release)(IResourceManager2 *This);
+ HRESULT (WINAPI *Enlist)(IResourceManager2 *This,ITransaction *pTransaction,ITransactionResourceAsync *pRes,XACTUOW *pUOW,LONG *pisoLevel,ITransactionEnlistmentAsync **ppEnlist);
+ HRESULT (WINAPI *Reenlist)(IResourceManager2 *This,byte *pPrepInfo,ULONG cbPrepInfo,DWORD lTimeout,XACTSTAT *pXactStat);
+ HRESULT (WINAPI *ReenlistmentComplete)(IResourceManager2 *This);
+ HRESULT (WINAPI *GetDistributedTransactionManager)(IResourceManager2 *This,REFIID iid,void **ppvObject);
+ HRESULT (WINAPI *Enlist2)(IResourceManager2 *This,ITransaction *pTransaction,ITransactionResourceAsync *pResAsync,XACTUOW *pUOW,LONG *pisoLevel,XID *pXid,ITransactionEnlistmentAsync **ppEnlist);
+ HRESULT (WINAPI *Reenlist2)(IResourceManager2 *This,XID *pXid,DWORD dwTimeout,XACTSTAT *pXactStat);
+ END_INTERFACE
+ } IResourceManager2Vtbl;
+ struct IResourceManager2 {
+ CONST_VTBL struct IResourceManager2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IResourceManager2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IResourceManager2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IResourceManager2_Release(This) (This)->lpVtbl->Release(This)
+#define IResourceManager2_Enlist(This,pTransaction,pRes,pUOW,pisoLevel,ppEnlist) (This)->lpVtbl->Enlist(This,pTransaction,pRes,pUOW,pisoLevel,ppEnlist)
+#define IResourceManager2_Reenlist(This,pPrepInfo,cbPrepInfo,lTimeout,pXactStat) (This)->lpVtbl->Reenlist(This,pPrepInfo,cbPrepInfo,lTimeout,pXactStat)
+#define IResourceManager2_ReenlistmentComplete(This) (This)->lpVtbl->ReenlistmentComplete(This)
+#define IResourceManager2_GetDistributedTransactionManager(This,iid,ppvObject) (This)->lpVtbl->GetDistributedTransactionManager(This,iid,ppvObject)
+#define IResourceManager2_Enlist2(This,pTransaction,pResAsync,pUOW,pisoLevel,pXid,ppEnlist) (This)->lpVtbl->Enlist2(This,pTransaction,pResAsync,pUOW,pisoLevel,pXid,ppEnlist)
+#define IResourceManager2_Reenlist2(This,pXid,dwTimeout,pXactStat) (This)->lpVtbl->Reenlist2(This,pXid,dwTimeout,pXactStat)
+#endif
+#endif
+ HRESULT WINAPI IResourceManager2_Enlist2_Proxy(IResourceManager2 *This,ITransaction *pTransaction,ITransactionResourceAsync *pResAsync,XACTUOW *pUOW,LONG *pisoLevel,XID *pXid,ITransactionEnlistmentAsync **ppEnlist);
+ void __RPC_STUB IResourceManager2_Enlist2_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IResourceManager2_Reenlist2_Proxy(IResourceManager2 *This,XID *pXid,DWORD dwTimeout,XACTSTAT *pXactStat);
+ void __RPC_STUB IResourceManager2_Reenlist2_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IXAConfig_INTERFACE_DEFINED__
+#define __IXAConfig_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IXAConfig;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IXAConfig : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Initialize(GUID clsidHelperDll) = 0;
+ virtual HRESULT WINAPI Terminate(void) = 0;
+ };
+#else
+ typedef struct IXAConfigVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IXAConfig *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IXAConfig *This);
+ ULONG (WINAPI *Release)(IXAConfig *This);
+ HRESULT (WINAPI *Initialize)(IXAConfig *This,GUID clsidHelperDll);
+ HRESULT (WINAPI *Terminate)(IXAConfig *This);
+ END_INTERFACE
+ } IXAConfigVtbl;
+ struct IXAConfig {
+ CONST_VTBL struct IXAConfigVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IXAConfig_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IXAConfig_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IXAConfig_Release(This) (This)->lpVtbl->Release(This)
+#define IXAConfig_Initialize(This,clsidHelperDll) (This)->lpVtbl->Initialize(This,clsidHelperDll)
+#define IXAConfig_Terminate(This) (This)->lpVtbl->Terminate(This)
+#endif
+#endif
+ HRESULT WINAPI IXAConfig_Initialize_Proxy(IXAConfig *This,GUID clsidHelperDll);
+ void __RPC_STUB IXAConfig_Initialize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IXAConfig_Terminate_Proxy(IXAConfig *This);
+ void __RPC_STUB IXAConfig_Terminate_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IRMHelper_INTERFACE_DEFINED__
+#define __IRMHelper_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IRMHelper;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IRMHelper : public IUnknown {
+ public:
+ virtual HRESULT WINAPI RMCount(DWORD dwcTotalNumberOfRMs) = 0;
+ virtual HRESULT WINAPI RMInfo(xa_switch_t *pXa_Switch,BOOL fCDeclCallingConv,char *pszOpenString,char *pszCloseString,GUID guidRMRecovery) = 0;
+ };
+#else
+ typedef struct IRMHelperVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IRMHelper *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IRMHelper *This);
+ ULONG (WINAPI *Release)(IRMHelper *This);
+ HRESULT (WINAPI *RMCount)(IRMHelper *This,DWORD dwcTotalNumberOfRMs);
+ HRESULT (WINAPI *RMInfo)(IRMHelper *This,xa_switch_t *pXa_Switch,BOOL fCDeclCallingConv,char *pszOpenString,char *pszCloseString,GUID guidRMRecovery);
+ END_INTERFACE
+ } IRMHelperVtbl;
+ struct IRMHelper {
+ CONST_VTBL struct IRMHelperVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IRMHelper_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IRMHelper_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IRMHelper_Release(This) (This)->lpVtbl->Release(This)
+#define IRMHelper_RMCount(This,dwcTotalNumberOfRMs) (This)->lpVtbl->RMCount(This,dwcTotalNumberOfRMs)
+#define IRMHelper_RMInfo(This,pXa_Switch,fCDeclCallingConv,pszOpenString,pszCloseString,guidRMRecovery) (This)->lpVtbl->RMInfo(This,pXa_Switch,fCDeclCallingConv,pszOpenString,pszCloseString,guidRMRecovery)
+#endif
+#endif
+ HRESULT WINAPI IRMHelper_RMCount_Proxy(IRMHelper *This,DWORD dwcTotalNumberOfRMs);
+ void __RPC_STUB IRMHelper_RMCount_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IRMHelper_RMInfo_Proxy(IRMHelper *This,xa_switch_t *pXa_Switch,BOOL fCDeclCallingConv,char *pszOpenString,char *pszCloseString,GUID guidRMRecovery);
+ void __RPC_STUB IRMHelper_RMInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IXAObtainRMInfo_INTERFACE_DEFINED__
+#define __IXAObtainRMInfo_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IXAObtainRMInfo;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IXAObtainRMInfo : public IUnknown {
+ public:
+ virtual HRESULT WINAPI ObtainRMInfo(IRMHelper *pIRMHelper) = 0;
+ };
+#else
+ typedef struct IXAObtainRMInfoVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IXAObtainRMInfo *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IXAObtainRMInfo *This);
+ ULONG (WINAPI *Release)(IXAObtainRMInfo *This);
+ HRESULT (WINAPI *ObtainRMInfo)(IXAObtainRMInfo *This,IRMHelper *pIRMHelper);
+ END_INTERFACE
+ } IXAObtainRMInfoVtbl;
+ struct IXAObtainRMInfo {
+ CONST_VTBL struct IXAObtainRMInfoVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IXAObtainRMInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IXAObtainRMInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IXAObtainRMInfo_Release(This) (This)->lpVtbl->Release(This)
+#define IXAObtainRMInfo_ObtainRMInfo(This,pIRMHelper) (This)->lpVtbl->ObtainRMInfo(This,pIRMHelper)
+#endif
+#endif
+ HRESULT WINAPI IXAObtainRMInfo_ObtainRMInfo_Proxy(IXAObtainRMInfo *This,IRMHelper *pIRMHelper);
+ void __RPC_STUB IXAObtainRMInfo_ObtainRMInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IResourceManagerFactory_INTERFACE_DEFINED__
+#define __IResourceManagerFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IResourceManagerFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IResourceManagerFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,IResourceManager **ppResMgr) = 0;
+ };
+#else
+ typedef struct IResourceManagerFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IResourceManagerFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IResourceManagerFactory *This);
+ ULONG (WINAPI *Release)(IResourceManagerFactory *This);
+ HRESULT (WINAPI *Create)(IResourceManagerFactory *This,GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,IResourceManager **ppResMgr);
+ END_INTERFACE
+ } IResourceManagerFactoryVtbl;
+ struct IResourceManagerFactory {
+ CONST_VTBL struct IResourceManagerFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IResourceManagerFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IResourceManagerFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IResourceManagerFactory_Release(This) (This)->lpVtbl->Release(This)
+#define IResourceManagerFactory_Create(This,pguidRM,pszRMName,pIResMgrSink,ppResMgr) (This)->lpVtbl->Create(This,pguidRM,pszRMName,pIResMgrSink,ppResMgr)
+#endif
+#endif
+ HRESULT WINAPI IResourceManagerFactory_Create_Proxy(IResourceManagerFactory *This,GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,IResourceManager **ppResMgr);
+ void __RPC_STUB IResourceManagerFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IResourceManagerFactory2_INTERFACE_DEFINED__
+#define __IResourceManagerFactory2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IResourceManagerFactory2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IResourceManagerFactory2 : public IResourceManagerFactory {
+ public:
+ virtual HRESULT WINAPI CreateEx(GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,REFIID riidRequested,void **ppvResMgr) = 0;
+ };
+#else
+ typedef struct IResourceManagerFactory2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IResourceManagerFactory2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IResourceManagerFactory2 *This);
+ ULONG (WINAPI *Release)(IResourceManagerFactory2 *This);
+ HRESULT (WINAPI *Create)(IResourceManagerFactory2 *This,GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,IResourceManager **ppResMgr);
+ HRESULT (WINAPI *CreateEx)(IResourceManagerFactory2 *This,GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,REFIID riidRequested,void **ppvResMgr);
+ END_INTERFACE
+ } IResourceManagerFactory2Vtbl;
+ struct IResourceManagerFactory2 {
+ CONST_VTBL struct IResourceManagerFactory2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IResourceManagerFactory2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IResourceManagerFactory2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IResourceManagerFactory2_Release(This) (This)->lpVtbl->Release(This)
+#define IResourceManagerFactory2_Create(This,pguidRM,pszRMName,pIResMgrSink,ppResMgr) (This)->lpVtbl->Create(This,pguidRM,pszRMName,pIResMgrSink,ppResMgr)
+#define IResourceManagerFactory2_CreateEx(This,pguidRM,pszRMName,pIResMgrSink,riidRequested,ppvResMgr) (This)->lpVtbl->CreateEx(This,pguidRM,pszRMName,pIResMgrSink,riidRequested,ppvResMgr)
+#endif
+#endif
+ HRESULT WINAPI IResourceManagerFactory2_CreateEx_Proxy(IResourceManagerFactory2 *This,GUID *pguidRM,CHAR *pszRMName,IResourceManagerSink *pIResMgrSink,REFIID riidRequested,void **ppvResMgr);
+ void __RPC_STUB IResourceManagerFactory2_CreateEx_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IPrepareInfo_INTERFACE_DEFINED__
+#define __IPrepareInfo_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IPrepareInfo;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IPrepareInfo : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetPrepareInfoSize(ULONG *pcbPrepInfo) = 0;
+ virtual HRESULT WINAPI GetPrepareInfo(byte *pPrepInfo) = 0;
+ };
+#else
+ typedef struct IPrepareInfoVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IPrepareInfo *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IPrepareInfo *This);
+ ULONG (WINAPI *Release)(IPrepareInfo *This);
+ HRESULT (WINAPI *GetPrepareInfoSize)(IPrepareInfo *This,ULONG *pcbPrepInfo);
+ HRESULT (WINAPI *GetPrepareInfo)(IPrepareInfo *This,byte *pPrepInfo);
+ END_INTERFACE
+ } IPrepareInfoVtbl;
+ struct IPrepareInfo {
+ CONST_VTBL struct IPrepareInfoVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IPrepareInfo_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IPrepareInfo_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IPrepareInfo_Release(This) (This)->lpVtbl->Release(This)
+#define IPrepareInfo_GetPrepareInfoSize(This,pcbPrepInfo) (This)->lpVtbl->GetPrepareInfoSize(This,pcbPrepInfo)
+#define IPrepareInfo_GetPrepareInfo(This,pPrepInfo) (This)->lpVtbl->GetPrepareInfo(This,pPrepInfo)
+#endif
+#endif
+ HRESULT WINAPI IPrepareInfo_GetPrepareInfoSize_Proxy(IPrepareInfo *This,ULONG *pcbPrepInfo);
+ void __RPC_STUB IPrepareInfo_GetPrepareInfoSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IPrepareInfo_GetPrepareInfo_Proxy(IPrepareInfo *This,byte *pPrepInfo);
+ void __RPC_STUB IPrepareInfo_GetPrepareInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IPrepareInfo2_INTERFACE_DEFINED__
+#define __IPrepareInfo2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IPrepareInfo2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IPrepareInfo2 : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetPrepareInfoSize(ULONG *pcbPrepInfo) = 0;
+ virtual HRESULT WINAPI GetPrepareInfo(ULONG cbPrepareInfo,byte *pPrepInfo) = 0;
+ };
+#else
+ typedef struct IPrepareInfo2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IPrepareInfo2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IPrepareInfo2 *This);
+ ULONG (WINAPI *Release)(IPrepareInfo2 *This);
+ HRESULT (WINAPI *GetPrepareInfoSize)(IPrepareInfo2 *This,ULONG *pcbPrepInfo);
+ HRESULT (WINAPI *GetPrepareInfo)(IPrepareInfo2 *This,ULONG cbPrepareInfo,byte *pPrepInfo);
+ END_INTERFACE
+ } IPrepareInfo2Vtbl;
+ struct IPrepareInfo2 {
+ CONST_VTBL struct IPrepareInfo2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IPrepareInfo2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IPrepareInfo2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IPrepareInfo2_Release(This) (This)->lpVtbl->Release(This)
+#define IPrepareInfo2_GetPrepareInfoSize(This,pcbPrepInfo) (This)->lpVtbl->GetPrepareInfoSize(This,pcbPrepInfo)
+#define IPrepareInfo2_GetPrepareInfo(This,cbPrepareInfo,pPrepInfo) (This)->lpVtbl->GetPrepareInfo(This,cbPrepareInfo,pPrepInfo)
+#endif
+#endif
+ HRESULT WINAPI IPrepareInfo2_GetPrepareInfoSize_Proxy(IPrepareInfo2 *This,ULONG *pcbPrepInfo);
+ void __RPC_STUB IPrepareInfo2_GetPrepareInfoSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IPrepareInfo2_GetPrepareInfo_Proxy(IPrepareInfo2 *This,ULONG cbPrepareInfo,byte *pPrepInfo);
+ void __RPC_STUB IPrepareInfo2_GetPrepareInfo_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IGetDispenser_INTERFACE_DEFINED__
+#define __IGetDispenser_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IGetDispenser;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IGetDispenser : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetDispenser(REFIID iid,void **ppvObject) = 0;
+ };
+#else
+ typedef struct IGetDispenserVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IGetDispenser *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IGetDispenser *This);
+ ULONG (WINAPI *Release)(IGetDispenser *This);
+ HRESULT (WINAPI *GetDispenser)(IGetDispenser *This,REFIID iid,void **ppvObject);
+ END_INTERFACE
+ } IGetDispenserVtbl;
+ struct IGetDispenser {
+ CONST_VTBL struct IGetDispenserVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IGetDispenser_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IGetDispenser_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IGetDispenser_Release(This) (This)->lpVtbl->Release(This)
+#define IGetDispenser_GetDispenser(This,iid,ppvObject) (This)->lpVtbl->GetDispenser(This,iid,ppvObject)
+#endif
+#endif
+ HRESULT WINAPI IGetDispenser_GetDispenser_Proxy(IGetDispenser *This,REFIID iid,void **ppvObject);
+ void __RPC_STUB IGetDispenser_GetDispenser_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionVoterBallotAsync2_INTERFACE_DEFINED__
+#define __ITransactionVoterBallotAsync2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionVoterBallotAsync2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionVoterBallotAsync2 : public IUnknown {
+ public:
+ virtual HRESULT WINAPI VoteRequestDone(HRESULT hr,BOID *pboidReason) = 0;
+ };
+#else
+ typedef struct ITransactionVoterBallotAsync2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionVoterBallotAsync2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionVoterBallotAsync2 *This);
+ ULONG (WINAPI *Release)(ITransactionVoterBallotAsync2 *This);
+ HRESULT (WINAPI *VoteRequestDone)(ITransactionVoterBallotAsync2 *This,HRESULT hr,BOID *pboidReason);
+ END_INTERFACE
+ } ITransactionVoterBallotAsync2Vtbl;
+ struct ITransactionVoterBallotAsync2 {
+ CONST_VTBL struct ITransactionVoterBallotAsync2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionVoterBallotAsync2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionVoterBallotAsync2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionVoterBallotAsync2_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionVoterBallotAsync2_VoteRequestDone(This,hr,pboidReason) (This)->lpVtbl->VoteRequestDone(This,hr,pboidReason)
+#endif
+#endif
+ HRESULT WINAPI ITransactionVoterBallotAsync2_VoteRequestDone_Proxy(ITransactionVoterBallotAsync2 *This,HRESULT hr,BOID *pboidReason);
+ void __RPC_STUB ITransactionVoterBallotAsync2_VoteRequestDone_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionVoterNotifyAsync2_INTERFACE_DEFINED__
+#define __ITransactionVoterNotifyAsync2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionVoterNotifyAsync2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionVoterNotifyAsync2 : public ITransactionOutcomeEvents {
+ public:
+ virtual HRESULT WINAPI VoteRequest(void) = 0;
+ };
+#else
+ typedef struct ITransactionVoterNotifyAsync2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionVoterNotifyAsync2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionVoterNotifyAsync2 *This);
+ ULONG (WINAPI *Release)(ITransactionVoterNotifyAsync2 *This);
+ HRESULT (WINAPI *Committed)(ITransactionVoterNotifyAsync2 *This,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr);
+ HRESULT (WINAPI *Aborted)(ITransactionVoterNotifyAsync2 *This,BOID *pboidReason,BOOL fRetaining,XACTUOW *pNewUOW,HRESULT hr);
+ HRESULT (WINAPI *HeuristicDecision)(ITransactionVoterNotifyAsync2 *This,DWORD dwDecision,BOID *pboidReason,HRESULT hr);
+ HRESULT (WINAPI *Indoubt)(ITransactionVoterNotifyAsync2 *This);
+ HRESULT (WINAPI *VoteRequest)(ITransactionVoterNotifyAsync2 *This);
+ END_INTERFACE
+ } ITransactionVoterNotifyAsync2Vtbl;
+ struct ITransactionVoterNotifyAsync2 {
+ CONST_VTBL struct ITransactionVoterNotifyAsync2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionVoterNotifyAsync2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionVoterNotifyAsync2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionVoterNotifyAsync2_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionVoterNotifyAsync2_Committed(This,fRetaining,pNewUOW,hr) (This)->lpVtbl->Committed(This,fRetaining,pNewUOW,hr)
+#define ITransactionVoterNotifyAsync2_Aborted(This,pboidReason,fRetaining,pNewUOW,hr) (This)->lpVtbl->Aborted(This,pboidReason,fRetaining,pNewUOW,hr)
+#define ITransactionVoterNotifyAsync2_HeuristicDecision(This,dwDecision,pboidReason,hr) (This)->lpVtbl->HeuristicDecision(This,dwDecision,pboidReason,hr)
+#define ITransactionVoterNotifyAsync2_Indoubt(This) (This)->lpVtbl->Indoubt(This)
+#define ITransactionVoterNotifyAsync2_VoteRequest(This) (This)->lpVtbl->VoteRequest(This)
+#endif
+#endif
+ HRESULT WINAPI ITransactionVoterNotifyAsync2_VoteRequest_Proxy(ITransactionVoterNotifyAsync2 *This);
+ void __RPC_STUB ITransactionVoterNotifyAsync2_VoteRequest_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionVoterFactory2_INTERFACE_DEFINED__
+#define __ITransactionVoterFactory2_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionVoterFactory2;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionVoterFactory2 : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(ITransaction *pTransaction,ITransactionVoterNotifyAsync2 *pVoterNotify,ITransactionVoterBallotAsync2 **ppVoterBallot) = 0;
+ };
+#else
+ typedef struct ITransactionVoterFactory2Vtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionVoterFactory2 *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionVoterFactory2 *This);
+ ULONG (WINAPI *Release)(ITransactionVoterFactory2 *This);
+ HRESULT (WINAPI *Create)(ITransactionVoterFactory2 *This,ITransaction *pTransaction,ITransactionVoterNotifyAsync2 *pVoterNotify,ITransactionVoterBallotAsync2 **ppVoterBallot);
+ END_INTERFACE
+ } ITransactionVoterFactory2Vtbl;
+ struct ITransactionVoterFactory2 {
+ CONST_VTBL struct ITransactionVoterFactory2Vtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionVoterFactory2_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionVoterFactory2_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionVoterFactory2_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionVoterFactory2_Create(This,pTransaction,pVoterNotify,ppVoterBallot) (This)->lpVtbl->Create(This,pTransaction,pVoterNotify,ppVoterBallot)
+#endif
+#endif
+ HRESULT WINAPI ITransactionVoterFactory2_Create_Proxy(ITransactionVoterFactory2 *This,ITransaction *pTransaction,ITransactionVoterNotifyAsync2 *pVoterNotify,ITransactionVoterBallotAsync2 **ppVoterBallot);
+ void __RPC_STUB ITransactionVoterFactory2_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionPhase0EnlistmentAsync_INTERFACE_DEFINED__
+#define __ITransactionPhase0EnlistmentAsync_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionPhase0EnlistmentAsync;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionPhase0EnlistmentAsync : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Enable(void) = 0;
+ virtual HRESULT WINAPI WaitForEnlistment(void) = 0;
+ virtual HRESULT WINAPI Phase0Done(void) = 0;
+ virtual HRESULT WINAPI Unenlist(void) = 0;
+ virtual HRESULT WINAPI GetTransaction(ITransaction **ppITransaction) = 0;
+ };
+#else
+ typedef struct ITransactionPhase0EnlistmentAsyncVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionPhase0EnlistmentAsync *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionPhase0EnlistmentAsync *This);
+ ULONG (WINAPI *Release)(ITransactionPhase0EnlistmentAsync *This);
+ HRESULT (WINAPI *Enable)(ITransactionPhase0EnlistmentAsync *This);
+ HRESULT (WINAPI *WaitForEnlistment)(ITransactionPhase0EnlistmentAsync *This);
+ HRESULT (WINAPI *Phase0Done)(ITransactionPhase0EnlistmentAsync *This);
+ HRESULT (WINAPI *Unenlist)(ITransactionPhase0EnlistmentAsync *This);
+ HRESULT (WINAPI *GetTransaction)(ITransactionPhase0EnlistmentAsync *This,ITransaction **ppITransaction);
+ END_INTERFACE
+ } ITransactionPhase0EnlistmentAsyncVtbl;
+ struct ITransactionPhase0EnlistmentAsync {
+ CONST_VTBL struct ITransactionPhase0EnlistmentAsyncVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionPhase0EnlistmentAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionPhase0EnlistmentAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionPhase0EnlistmentAsync_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionPhase0EnlistmentAsync_Enable(This) (This)->lpVtbl->Enable(This)
+#define ITransactionPhase0EnlistmentAsync_WaitForEnlistment(This) (This)->lpVtbl->WaitForEnlistment(This)
+#define ITransactionPhase0EnlistmentAsync_Phase0Done(This) (This)->lpVtbl->Phase0Done(This)
+#define ITransactionPhase0EnlistmentAsync_Unenlist(This) (This)->lpVtbl->Unenlist(This)
+#define ITransactionPhase0EnlistmentAsync_GetTransaction(This,ppITransaction) (This)->lpVtbl->GetTransaction(This,ppITransaction)
+#endif
+#endif
+ HRESULT WINAPI ITransactionPhase0EnlistmentAsync_Enable_Proxy(ITransactionPhase0EnlistmentAsync *This);
+ void __RPC_STUB ITransactionPhase0EnlistmentAsync_Enable_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionPhase0EnlistmentAsync_WaitForEnlistment_Proxy(ITransactionPhase0EnlistmentAsync *This);
+ void __RPC_STUB ITransactionPhase0EnlistmentAsync_WaitForEnlistment_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionPhase0EnlistmentAsync_Phase0Done_Proxy(ITransactionPhase0EnlistmentAsync *This);
+ void __RPC_STUB ITransactionPhase0EnlistmentAsync_Phase0Done_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionPhase0EnlistmentAsync_Unenlist_Proxy(ITransactionPhase0EnlistmentAsync *This);
+ void __RPC_STUB ITransactionPhase0EnlistmentAsync_Unenlist_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionPhase0EnlistmentAsync_GetTransaction_Proxy(ITransactionPhase0EnlistmentAsync *This,ITransaction **ppITransaction);
+ void __RPC_STUB ITransactionPhase0EnlistmentAsync_GetTransaction_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionPhase0NotifyAsync_INTERFACE_DEFINED__
+#define __ITransactionPhase0NotifyAsync_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionPhase0NotifyAsync;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionPhase0NotifyAsync : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Phase0Request(BOOL fAbortingHint) = 0;
+ virtual HRESULT WINAPI EnlistCompleted(HRESULT status) = 0;
+ };
+#else
+ typedef struct ITransactionPhase0NotifyAsyncVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionPhase0NotifyAsync *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionPhase0NotifyAsync *This);
+ ULONG (WINAPI *Release)(ITransactionPhase0NotifyAsync *This);
+ HRESULT (WINAPI *Phase0Request)(ITransactionPhase0NotifyAsync *This,BOOL fAbortingHint);
+ HRESULT (WINAPI *EnlistCompleted)(ITransactionPhase0NotifyAsync *This,HRESULT status);
+ END_INTERFACE
+ } ITransactionPhase0NotifyAsyncVtbl;
+ struct ITransactionPhase0NotifyAsync {
+ CONST_VTBL struct ITransactionPhase0NotifyAsyncVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionPhase0NotifyAsync_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionPhase0NotifyAsync_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionPhase0NotifyAsync_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionPhase0NotifyAsync_Phase0Request(This,fAbortingHint) (This)->lpVtbl->Phase0Request(This,fAbortingHint)
+#define ITransactionPhase0NotifyAsync_EnlistCompleted(This,status) (This)->lpVtbl->EnlistCompleted(This,status)
+#endif
+#endif
+ HRESULT WINAPI ITransactionPhase0NotifyAsync_Phase0Request_Proxy(ITransactionPhase0NotifyAsync *This,BOOL fAbortingHint);
+ void __RPC_STUB ITransactionPhase0NotifyAsync_Phase0Request_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionPhase0NotifyAsync_EnlistCompleted_Proxy(ITransactionPhase0NotifyAsync *This,HRESULT status);
+ void __RPC_STUB ITransactionPhase0NotifyAsync_EnlistCompleted_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionPhase0Factory_INTERFACE_DEFINED__
+#define __ITransactionPhase0Factory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionPhase0Factory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionPhase0Factory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(ITransactionPhase0NotifyAsync *pPhase0Notify,ITransactionPhase0EnlistmentAsync **ppPhase0Enlistment) = 0;
+ };
+#else
+ typedef struct ITransactionPhase0FactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionPhase0Factory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionPhase0Factory *This);
+ ULONG (WINAPI *Release)(ITransactionPhase0Factory *This);
+ HRESULT (WINAPI *Create)(ITransactionPhase0Factory *This,ITransactionPhase0NotifyAsync *pPhase0Notify,ITransactionPhase0EnlistmentAsync **ppPhase0Enlistment);
+ END_INTERFACE
+ } ITransactionPhase0FactoryVtbl;
+ struct ITransactionPhase0Factory {
+ CONST_VTBL struct ITransactionPhase0FactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionPhase0Factory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionPhase0Factory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionPhase0Factory_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionPhase0Factory_Create(This,pPhase0Notify,ppPhase0Enlistment) (This)->lpVtbl->Create(This,pPhase0Notify,ppPhase0Enlistment)
+#endif
+#endif
+ HRESULT WINAPI ITransactionPhase0Factory_Create_Proxy(ITransactionPhase0Factory *This,ITransactionPhase0NotifyAsync *pPhase0Notify,ITransactionPhase0EnlistmentAsync **ppPhase0Enlistment);
+ void __RPC_STUB ITransactionPhase0Factory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionTransmitter_INTERFACE_DEFINED__
+#define __ITransactionTransmitter_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionTransmitter;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionTransmitter : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Set(ITransaction *pTransaction) = 0;
+ virtual HRESULT WINAPI GetPropagationTokenSize(ULONG *pcbToken) = 0;
+ virtual HRESULT WINAPI MarshalPropagationToken(ULONG cbToken,byte *rgbToken,ULONG *pcbUsed) = 0;
+ virtual HRESULT WINAPI UnmarshalReturnToken(ULONG cbReturnToken,byte *rgbReturnToken) = 0;
+ virtual HRESULT WINAPI Reset(void) = 0;
+ };
+#else
+ typedef struct ITransactionTransmitterVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionTransmitter *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionTransmitter *This);
+ ULONG (WINAPI *Release)(ITransactionTransmitter *This);
+ HRESULT (WINAPI *Set)(ITransactionTransmitter *This,ITransaction *pTransaction);
+ HRESULT (WINAPI *GetPropagationTokenSize)(ITransactionTransmitter *This,ULONG *pcbToken);
+ HRESULT (WINAPI *MarshalPropagationToken)(ITransactionTransmitter *This,ULONG cbToken,byte *rgbToken,ULONG *pcbUsed);
+ HRESULT (WINAPI *UnmarshalReturnToken)(ITransactionTransmitter *This,ULONG cbReturnToken,byte *rgbReturnToken);
+ HRESULT (WINAPI *Reset)(ITransactionTransmitter *This);
+ END_INTERFACE
+ } ITransactionTransmitterVtbl;
+ struct ITransactionTransmitter {
+ CONST_VTBL struct ITransactionTransmitterVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionTransmitter_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionTransmitter_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionTransmitter_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionTransmitter_Set(This,pTransaction) (This)->lpVtbl->Set(This,pTransaction)
+#define ITransactionTransmitter_GetPropagationTokenSize(This,pcbToken) (This)->lpVtbl->GetPropagationTokenSize(This,pcbToken)
+#define ITransactionTransmitter_MarshalPropagationToken(This,cbToken,rgbToken,pcbUsed) (This)->lpVtbl->MarshalPropagationToken(This,cbToken,rgbToken,pcbUsed)
+#define ITransactionTransmitter_UnmarshalReturnToken(This,cbReturnToken,rgbReturnToken) (This)->lpVtbl->UnmarshalReturnToken(This,cbReturnToken,rgbReturnToken)
+#define ITransactionTransmitter_Reset(This) (This)->lpVtbl->Reset(This)
+#endif
+#endif
+ HRESULT WINAPI ITransactionTransmitter_Set_Proxy(ITransactionTransmitter *This,ITransaction *pTransaction);
+ void __RPC_STUB ITransactionTransmitter_Set_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionTransmitter_GetPropagationTokenSize_Proxy(ITransactionTransmitter *This,ULONG *pcbToken);
+ void __RPC_STUB ITransactionTransmitter_GetPropagationTokenSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionTransmitter_MarshalPropagationToken_Proxy(ITransactionTransmitter *This,ULONG cbToken,byte *rgbToken,ULONG *pcbUsed);
+ void __RPC_STUB ITransactionTransmitter_MarshalPropagationToken_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionTransmitter_UnmarshalReturnToken_Proxy(ITransactionTransmitter *This,ULONG cbReturnToken,byte *rgbReturnToken);
+ void __RPC_STUB ITransactionTransmitter_UnmarshalReturnToken_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionTransmitter_Reset_Proxy(ITransactionTransmitter *This);
+ void __RPC_STUB ITransactionTransmitter_Reset_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionTransmitterFactory_INTERFACE_DEFINED__
+#define __ITransactionTransmitterFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionTransmitterFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionTransmitterFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(ITransactionTransmitter **ppTransmitter) = 0;
+ };
+#else
+ typedef struct ITransactionTransmitterFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionTransmitterFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionTransmitterFactory *This);
+ ULONG (WINAPI *Release)(ITransactionTransmitterFactory *This);
+ HRESULT (WINAPI *Create)(ITransactionTransmitterFactory *This,ITransactionTransmitter **ppTransmitter);
+ END_INTERFACE
+ } ITransactionTransmitterFactoryVtbl;
+ struct ITransactionTransmitterFactory {
+ CONST_VTBL struct ITransactionTransmitterFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionTransmitterFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionTransmitterFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionTransmitterFactory_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionTransmitterFactory_Create(This,ppTransmitter) (This)->lpVtbl->Create(This,ppTransmitter)
+#endif
+#endif
+ HRESULT WINAPI ITransactionTransmitterFactory_Create_Proxy(ITransactionTransmitterFactory *This,ITransactionTransmitter **ppTransmitter);
+ void __RPC_STUB ITransactionTransmitterFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionReceiver_INTERFACE_DEFINED__
+#define __ITransactionReceiver_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionReceiver;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionReceiver : public IUnknown {
+ public:
+ virtual HRESULT WINAPI UnmarshalPropagationToken(ULONG cbToken,byte *rgbToken,ITransaction **ppTransaction) = 0;
+ virtual HRESULT WINAPI GetReturnTokenSize(ULONG *pcbReturnToken) = 0;
+ virtual HRESULT WINAPI MarshalReturnToken(ULONG cbReturnToken,byte *rgbReturnToken,ULONG *pcbUsed) = 0;
+ virtual HRESULT WINAPI Reset(void) = 0;
+ };
+#else
+ typedef struct ITransactionReceiverVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionReceiver *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionReceiver *This);
+ ULONG (WINAPI *Release)(ITransactionReceiver *This);
+ HRESULT (WINAPI *UnmarshalPropagationToken)(ITransactionReceiver *This,ULONG cbToken,byte *rgbToken,ITransaction **ppTransaction);
+ HRESULT (WINAPI *GetReturnTokenSize)(ITransactionReceiver *This,ULONG *pcbReturnToken);
+ HRESULT (WINAPI *MarshalReturnToken)(ITransactionReceiver *This,ULONG cbReturnToken,byte *rgbReturnToken,ULONG *pcbUsed);
+ HRESULT (WINAPI *Reset)(ITransactionReceiver *This);
+ END_INTERFACE
+ } ITransactionReceiverVtbl;
+ struct ITransactionReceiver {
+ CONST_VTBL struct ITransactionReceiverVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionReceiver_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionReceiver_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionReceiver_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionReceiver_UnmarshalPropagationToken(This,cbToken,rgbToken,ppTransaction) (This)->lpVtbl->UnmarshalPropagationToken(This,cbToken,rgbToken,ppTransaction)
+#define ITransactionReceiver_GetReturnTokenSize(This,pcbReturnToken) (This)->lpVtbl->GetReturnTokenSize(This,pcbReturnToken)
+#define ITransactionReceiver_MarshalReturnToken(This,cbReturnToken,rgbReturnToken,pcbUsed) (This)->lpVtbl->MarshalReturnToken(This,cbReturnToken,rgbReturnToken,pcbUsed)
+#define ITransactionReceiver_Reset(This) (This)->lpVtbl->Reset(This)
+#endif
+#endif
+ HRESULT WINAPI ITransactionReceiver_UnmarshalPropagationToken_Proxy(ITransactionReceiver *This,ULONG cbToken,byte *rgbToken,ITransaction **ppTransaction);
+ void __RPC_STUB ITransactionReceiver_UnmarshalPropagationToken_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionReceiver_GetReturnTokenSize_Proxy(ITransactionReceiver *This,ULONG *pcbReturnToken);
+ void __RPC_STUB ITransactionReceiver_GetReturnTokenSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionReceiver_MarshalReturnToken_Proxy(ITransactionReceiver *This,ULONG cbReturnToken,byte *rgbReturnToken,ULONG *pcbUsed);
+ void __RPC_STUB ITransactionReceiver_MarshalReturnToken_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI ITransactionReceiver_Reset_Proxy(ITransactionReceiver *This);
+ void __RPC_STUB ITransactionReceiver_Reset_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __ITransactionReceiverFactory_INTERFACE_DEFINED__
+#define __ITransactionReceiverFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_ITransactionReceiverFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct ITransactionReceiverFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(ITransactionReceiver **ppReceiver) = 0;
+ };
+#else
+ typedef struct ITransactionReceiverFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(ITransactionReceiverFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(ITransactionReceiverFactory *This);
+ ULONG (WINAPI *Release)(ITransactionReceiverFactory *This);
+ HRESULT (WINAPI *Create)(ITransactionReceiverFactory *This,ITransactionReceiver **ppReceiver);
+ END_INTERFACE
+ } ITransactionReceiverFactoryVtbl;
+ struct ITransactionReceiverFactory {
+ CONST_VTBL struct ITransactionReceiverFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define ITransactionReceiverFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define ITransactionReceiverFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define ITransactionReceiverFactory_Release(This) (This)->lpVtbl->Release(This)
+#define ITransactionReceiverFactory_Create(This,ppReceiver) (This)->lpVtbl->Create(This,ppReceiver)
+#endif
+#endif
+ HRESULT WINAPI ITransactionReceiverFactory_Create_Proxy(ITransactionReceiverFactory *This,ITransactionReceiver **ppReceiver);
+ void __RPC_STUB ITransactionReceiverFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+ typedef struct _ProxyConfigParams {
+ WORD wcThreadsMax;
+ } PROXY_CONFIG_PARAMS;
+
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0141_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0141_v0_0_s_ifspec;
+#ifndef __IDtcLuConfigure_INTERFACE_DEFINED__
+#define __IDtcLuConfigure_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuConfigure;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuConfigure : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Add(byte *pucLuPair,DWORD cbLuPair) = 0;
+ virtual HRESULT WINAPI Delete(byte *pucLuPair,DWORD cbLuPair) = 0;
+ };
+#else
+ typedef struct IDtcLuConfigureVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuConfigure *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuConfigure *This);
+ ULONG (WINAPI *Release)(IDtcLuConfigure *This);
+ HRESULT (WINAPI *Add)(IDtcLuConfigure *This,byte *pucLuPair,DWORD cbLuPair);
+ HRESULT (WINAPI *Delete)(IDtcLuConfigure *This,byte *pucLuPair,DWORD cbLuPair);
+ END_INTERFACE
+ } IDtcLuConfigureVtbl;
+ struct IDtcLuConfigure {
+ CONST_VTBL struct IDtcLuConfigureVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuConfigure_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuConfigure_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuConfigure_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuConfigure_Add(This,pucLuPair,cbLuPair) (This)->lpVtbl->Add(This,pucLuPair,cbLuPair)
+#define IDtcLuConfigure_Delete(This,pucLuPair,cbLuPair) (This)->lpVtbl->Delete(This,pucLuPair,cbLuPair)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuConfigure_Add_Proxy(IDtcLuConfigure *This,byte *pucLuPair,DWORD cbLuPair);
+ void __RPC_STUB IDtcLuConfigure_Add_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuConfigure_Delete_Proxy(IDtcLuConfigure *This,byte *pucLuPair,DWORD cbLuPair);
+ void __RPC_STUB IDtcLuConfigure_Delete_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRecovery_INTERFACE_DEFINED__
+#define __IDtcLuRecovery_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecovery;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecovery : public IUnknown {
+ };
+#else
+ typedef struct IDtcLuRecoveryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecovery *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecovery *This);
+ ULONG (WINAPI *Release)(IDtcLuRecovery *This);
+ END_INTERFACE
+ } IDtcLuRecoveryVtbl;
+ struct IDtcLuRecovery {
+ CONST_VTBL struct IDtcLuRecoveryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecovery_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecovery_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecovery_Release(This) (This)->lpVtbl->Release(This)
+#endif
+#endif
+#endif
+
+#ifndef __IDtcLuRecoveryFactory_INTERFACE_DEFINED__
+#define __IDtcLuRecoveryFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecoveryFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecoveryFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(byte *pucLuPair,DWORD cbLuPair,IDtcLuRecovery **ppRecovery) = 0;
+ };
+#else
+ typedef struct IDtcLuRecoveryFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecoveryFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecoveryFactory *This);
+ ULONG (WINAPI *Release)(IDtcLuRecoveryFactory *This);
+ HRESULT (WINAPI *Create)(IDtcLuRecoveryFactory *This,byte *pucLuPair,DWORD cbLuPair,IDtcLuRecovery **ppRecovery);
+ END_INTERFACE
+ } IDtcLuRecoveryFactoryVtbl;
+ struct IDtcLuRecoveryFactory {
+ CONST_VTBL struct IDtcLuRecoveryFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecoveryFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecoveryFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecoveryFactory_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRecoveryFactory_Create(This,pucLuPair,cbLuPair,ppRecovery) (This)->lpVtbl->Create(This,pucLuPair,cbLuPair,ppRecovery)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRecoveryFactory_Create_Proxy(IDtcLuRecoveryFactory *This,byte *pucLuPair,DWORD cbLuPair,IDtcLuRecovery **ppRecovery);
+ void __RPC_STUB IDtcLuRecoveryFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+ typedef enum _DtcLu_LocalRecovery_Work {
+ DTCINITIATEDRECOVERYWORK_CHECKLUSTATUS = 1,
+ DTCINITIATEDRECOVERYWORK_TRANS,DTCINITIATEDRECOVERYWORK_TMDOWN
+ } DTCINITIATEDRECOVERYWORK;
+
+ typedef enum _DtcLu_Xln {
+ DTCLUXLN_COLD = 1,DTCLUXLN_WARM
+ } DTCLUXLN;
+
+ typedef enum _DtcLu_Xln_Confirmation {
+ DTCLUXLNCONFIRMATION_CONFIRM = 1,
+ DTCLUXLNCONFIRMATION_LOGNAMEMISMATCH,DTCLUXLNCONFIRMATION_COLDWARMMISMATCH,
+ DTCLUXLNCONFIRMATION_OBSOLETE
+ } DTCLUXLNCONFIRMATION;
+
+ typedef enum _DtcLu_Xln_Response {
+ DTCLUXLNRESPONSE_OK_SENDOURXLNBACK = 1,
+ DTCLUXLNRESPONSE_OK_SENDCONFIRMATION,DTCLUXLNRESPONSE_LOGNAMEMISMATCH,
+ DTCLUXLNRESPONSE_COLDWARMMISMATCH
+ } DTCLUXLNRESPONSE;
+
+ typedef enum _DtcLu_Xln_Error {
+ DTCLUXLNERROR_PROTOCOL = 1,
+ DTCLUXLNERROR_LOGNAMEMISMATCH,DTCLUXLNERROR_COLDWARMMISMATCH
+ } DTCLUXLNERROR;
+
+ typedef enum _DtcLu_CompareState {
+ DTCLUCOMPARESTATE_COMMITTED = 1,
+ DTCLUCOMPARESTATE_HEURISTICCOMMITTED,DTCLUCOMPARESTATE_HEURISTICMIXED,
+ DTCLUCOMPARESTATE_HEURISTICRESET,DTCLUCOMPARESTATE_INDOUBT,DTCLUCOMPARESTATE_RESET
+ } DTCLUCOMPARESTATE;
+
+ typedef enum _DtcLu_CompareStates_Confirmation {
+ DTCLUCOMPARESTATESCONFIRMATION_CONFIRM = 1,
+ DTCLUCOMPARESTATESCONFIRMATION_PROTOCOL
+ } DTCLUCOMPARESTATESCONFIRMATION;
+
+ typedef enum _DtcLu_CompareStates_Error {
+ DTCLUCOMPARESTATESERROR_PROTOCOL = 1
+ } DTCLUCOMPARESTATESERROR;
+
+ typedef enum _DtcLu_CompareStates_Response {
+ DTCLUCOMPARESTATESRESPONSE_OK = 1,
+ DTCLUCOMPARESTATESRESPONSE_PROTOCOL
+ } DTCLUCOMPARESTATESRESPONSE;
+
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0144_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0144_v0_0_s_ifspec;
+#ifndef __IDtcLuRecoveryInitiatedByDtcTransWork_INTERFACE_DEFINED__
+#define __IDtcLuRecoveryInitiatedByDtcTransWork_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecoveryInitiatedByDtcTransWork;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecoveryInitiatedByDtcTransWork : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetLogNameSizes(DWORD *pcbOurLogName,DWORD *pcbRemoteLogName) = 0;
+ virtual HRESULT WINAPI GetOurXln(DTCLUXLN *pXln,unsigned char *pOurLogName,unsigned char *pRemoteLogName,DWORD *pdwProtocol) = 0;
+ virtual HRESULT WINAPI HandleConfirmationFromOurXln(DTCLUXLNCONFIRMATION Confirmation) = 0;
+ virtual HRESULT WINAPI HandleTheirXlnResponse(DTCLUXLN Xln,unsigned char *pRemoteLogName,DWORD cbRemoteLogName,DWORD dwProtocol,DTCLUXLNCONFIRMATION *pConfirmation) = 0;
+ virtual HRESULT WINAPI HandleErrorFromOurXln(DTCLUXLNERROR Error) = 0;
+ virtual HRESULT WINAPI CheckForCompareStates(BOOL *fCompareStates) = 0;
+ virtual HRESULT WINAPI GetOurTransIdSize(DWORD *pcbOurTransId) = 0;
+ virtual HRESULT WINAPI GetOurCompareStates(unsigned char *pOurTransId,DTCLUCOMPARESTATE *pCompareState) = 0;
+ virtual HRESULT WINAPI HandleTheirCompareStatesResponse(DTCLUCOMPARESTATE CompareState,DTCLUCOMPARESTATESCONFIRMATION *pConfirmation) = 0;
+ virtual HRESULT WINAPI HandleErrorFromOurCompareStates(DTCLUCOMPARESTATESERROR Error) = 0;
+ virtual HRESULT WINAPI ConversationLost(void) = 0;
+ virtual HRESULT WINAPI GetRecoverySeqNum(LONG *plRecoverySeqNum) = 0;
+ virtual HRESULT WINAPI ObsoleteRecoverySeqNum(LONG lNewRecoverySeqNum) = 0;
+ };
+#else
+ typedef struct IDtcLuRecoveryInitiatedByDtcTransWorkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecoveryInitiatedByDtcTransWork *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecoveryInitiatedByDtcTransWork *This);
+ ULONG (WINAPI *Release)(IDtcLuRecoveryInitiatedByDtcTransWork *This);
+ HRESULT (WINAPI *GetLogNameSizes)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DWORD *pcbOurLogName,DWORD *pcbRemoteLogName);
+ HRESULT (WINAPI *GetOurXln)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLN *pXln,unsigned char *pOurLogName,unsigned char *pRemoteLogName,DWORD *pdwProtocol);
+ HRESULT (WINAPI *HandleConfirmationFromOurXln)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLNCONFIRMATION Confirmation);
+ HRESULT (WINAPI *HandleTheirXlnResponse)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLN Xln,unsigned char *pRemoteLogName,DWORD cbRemoteLogName,DWORD dwProtocol,DTCLUXLNCONFIRMATION *pConfirmation);
+ HRESULT (WINAPI *HandleErrorFromOurXln)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLNERROR Error);
+ HRESULT (WINAPI *CheckForCompareStates)(IDtcLuRecoveryInitiatedByDtcTransWork *This,BOOL *fCompareStates);
+ HRESULT (WINAPI *GetOurTransIdSize)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DWORD *pcbOurTransId);
+ HRESULT (WINAPI *GetOurCompareStates)(IDtcLuRecoveryInitiatedByDtcTransWork *This,unsigned char *pOurTransId,DTCLUCOMPARESTATE *pCompareState);
+ HRESULT (WINAPI *HandleTheirCompareStatesResponse)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUCOMPARESTATE CompareState,DTCLUCOMPARESTATESCONFIRMATION *pConfirmation);
+ HRESULT (WINAPI *HandleErrorFromOurCompareStates)(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUCOMPARESTATESERROR Error);
+ HRESULT (WINAPI *ConversationLost)(IDtcLuRecoveryInitiatedByDtcTransWork *This);
+ HRESULT (WINAPI *GetRecoverySeqNum)(IDtcLuRecoveryInitiatedByDtcTransWork *This,LONG *plRecoverySeqNum);
+ HRESULT (WINAPI *ObsoleteRecoverySeqNum)(IDtcLuRecoveryInitiatedByDtcTransWork *This,LONG lNewRecoverySeqNum);
+ END_INTERFACE
+ } IDtcLuRecoveryInitiatedByDtcTransWorkVtbl;
+ struct IDtcLuRecoveryInitiatedByDtcTransWork {
+ CONST_VTBL struct IDtcLuRecoveryInitiatedByDtcTransWorkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecoveryInitiatedByDtcTransWork_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_GetLogNameSizes(This,pcbOurLogName,pcbRemoteLogName) (This)->lpVtbl->GetLogNameSizes(This,pcbOurLogName,pcbRemoteLogName)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_GetOurXln(This,pXln,pOurLogName,pRemoteLogName,pdwProtocol) (This)->lpVtbl->GetOurXln(This,pXln,pOurLogName,pRemoteLogName,pdwProtocol)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_HandleConfirmationFromOurXln(This,Confirmation) (This)->lpVtbl->HandleConfirmationFromOurXln(This,Confirmation)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirXlnResponse(This,Xln,pRemoteLogName,cbRemoteLogName,dwProtocol,pConfirmation) (This)->lpVtbl->HandleTheirXlnResponse(This,Xln,pRemoteLogName,cbRemoteLogName,dwProtocol,pConfirmation)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurXln(This,Error) (This)->lpVtbl->HandleErrorFromOurXln(This,Error)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_CheckForCompareStates(This,fCompareStates) (This)->lpVtbl->CheckForCompareStates(This,fCompareStates)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_GetOurTransIdSize(This,pcbOurTransId) (This)->lpVtbl->GetOurTransIdSize(This,pcbOurTransId)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_GetOurCompareStates(This,pOurTransId,pCompareState) (This)->lpVtbl->GetOurCompareStates(This,pOurTransId,pCompareState)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirCompareStatesResponse(This,CompareState,pConfirmation) (This)->lpVtbl->HandleTheirCompareStatesResponse(This,CompareState,pConfirmation)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurCompareStates(This,Error) (This)->lpVtbl->HandleErrorFromOurCompareStates(This,Error)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_ConversationLost(This) (This)->lpVtbl->ConversationLost(This)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_GetRecoverySeqNum(This,plRecoverySeqNum) (This)->lpVtbl->GetRecoverySeqNum(This,plRecoverySeqNum)
+#define IDtcLuRecoveryInitiatedByDtcTransWork_ObsoleteRecoverySeqNum(This,lNewRecoverySeqNum) (This)->lpVtbl->ObsoleteRecoverySeqNum(This,lNewRecoverySeqNum)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_GetLogNameSizes_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DWORD *pcbOurLogName,DWORD *pcbRemoteLogName);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_GetLogNameSizes_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_GetOurXln_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLN *pXln,unsigned char *pOurLogName,unsigned char *pRemoteLogName,DWORD *pdwProtocol);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_GetOurXln_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_HandleConfirmationFromOurXln_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLNCONFIRMATION Confirmation);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_HandleConfirmationFromOurXln_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirXlnResponse_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLN Xln,unsigned char *pRemoteLogName,DWORD cbRemoteLogName,DWORD dwProtocol,DTCLUXLNCONFIRMATION *pConfirmation);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirXlnResponse_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurXln_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUXLNERROR Error);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurXln_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_CheckForCompareStates_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,BOOL *fCompareStates);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_CheckForCompareStates_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_GetOurTransIdSize_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DWORD *pcbOurTransId);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_GetOurTransIdSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_GetOurCompareStates_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,unsigned char *pOurTransId,DTCLUCOMPARESTATE *pCompareState);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_GetOurCompareStates_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirCompareStatesResponse_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUCOMPARESTATE CompareState,DTCLUCOMPARESTATESCONFIRMATION *pConfirmation);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_HandleTheirCompareStatesResponse_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurCompareStates_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,DTCLUCOMPARESTATESERROR Error);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_HandleErrorFromOurCompareStates_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_ConversationLost_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_ConversationLost_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_GetRecoverySeqNum_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,LONG *plRecoverySeqNum);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_GetRecoverySeqNum_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcTransWork_ObsoleteRecoverySeqNum_Proxy(IDtcLuRecoveryInitiatedByDtcTransWork *This,LONG lNewRecoverySeqNum);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcTransWork_ObsoleteRecoverySeqNum_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByDtcStatusWork_INTERFACE_DEFINED__
+#define __IDtcLuRecoveryInitiatedByDtcStatusWork_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecoveryInitiatedByDtcStatusWork;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecoveryInitiatedByDtcStatusWork : public IUnknown {
+ public:
+ virtual HRESULT WINAPI HandleCheckLuStatus(LONG lRecoverySeqNum) = 0;
+ };
+#else
+ typedef struct IDtcLuRecoveryInitiatedByDtcStatusWorkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecoveryInitiatedByDtcStatusWork *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecoveryInitiatedByDtcStatusWork *This);
+ ULONG (WINAPI *Release)(IDtcLuRecoveryInitiatedByDtcStatusWork *This);
+ HRESULT (WINAPI *HandleCheckLuStatus)(IDtcLuRecoveryInitiatedByDtcStatusWork *This,LONG lRecoverySeqNum);
+ END_INTERFACE
+ } IDtcLuRecoveryInitiatedByDtcStatusWorkVtbl;
+ struct IDtcLuRecoveryInitiatedByDtcStatusWork {
+ CONST_VTBL struct IDtcLuRecoveryInitiatedByDtcStatusWorkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecoveryInitiatedByDtcStatusWork_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecoveryInitiatedByDtcStatusWork_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecoveryInitiatedByDtcStatusWork_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRecoveryInitiatedByDtcStatusWork_HandleCheckLuStatus(This,lRecoverySeqNum) (This)->lpVtbl->HandleCheckLuStatus(This,lRecoverySeqNum)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtcStatusWork_HandleCheckLuStatus_Proxy(IDtcLuRecoveryInitiatedByDtcStatusWork *This,LONG lRecoverySeqNum);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtcStatusWork_HandleCheckLuStatus_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByDtc_INTERFACE_DEFINED__
+#define __IDtcLuRecoveryInitiatedByDtc_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecoveryInitiatedByDtc;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecoveryInitiatedByDtc : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetWork(DTCINITIATEDRECOVERYWORK *pWork,void **ppv) = 0;
+ };
+#else
+ typedef struct IDtcLuRecoveryInitiatedByDtcVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecoveryInitiatedByDtc *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecoveryInitiatedByDtc *This);
+ ULONG (WINAPI *Release)(IDtcLuRecoveryInitiatedByDtc *This);
+ HRESULT (WINAPI *GetWork)(IDtcLuRecoveryInitiatedByDtc *This,DTCINITIATEDRECOVERYWORK *pWork,void **ppv);
+ END_INTERFACE
+ } IDtcLuRecoveryInitiatedByDtcVtbl;
+ struct IDtcLuRecoveryInitiatedByDtc {
+ CONST_VTBL struct IDtcLuRecoveryInitiatedByDtcVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecoveryInitiatedByDtc_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecoveryInitiatedByDtc_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecoveryInitiatedByDtc_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRecoveryInitiatedByDtc_GetWork(This,pWork,ppv) (This)->lpVtbl->GetWork(This,pWork,ppv)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByDtc_GetWork_Proxy(IDtcLuRecoveryInitiatedByDtc *This,DTCINITIATEDRECOVERYWORK *pWork,void **ppv);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByDtc_GetWork_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByLuWork_INTERFACE_DEFINED__
+#define __IDtcLuRecoveryInitiatedByLuWork_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecoveryInitiatedByLuWork;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecoveryInitiatedByLuWork : public IUnknown {
+ public:
+ virtual HRESULT WINAPI HandleTheirXln(LONG lRecoverySeqNum,DTCLUXLN Xln,unsigned char *pRemoteLogName,DWORD cbRemoteLogName,unsigned char *pOurLogName,DWORD cbOurLogName,DWORD dwProtocol,DTCLUXLNRESPONSE *pResponse) = 0;
+ virtual HRESULT WINAPI GetOurLogNameSize(DWORD *pcbOurLogName) = 0;
+ virtual HRESULT WINAPI GetOurXln(DTCLUXLN *pXln,unsigned char *pOurLogName,DWORD *pdwProtocol) = 0;
+ virtual HRESULT WINAPI HandleConfirmationOfOurXln(DTCLUXLNCONFIRMATION Confirmation) = 0;
+ virtual HRESULT WINAPI HandleTheirCompareStates(unsigned char *pRemoteTransId,DWORD cbRemoteTransId,DTCLUCOMPARESTATE CompareState,DTCLUCOMPARESTATESRESPONSE *pResponse,DTCLUCOMPARESTATE *pCompareState) = 0;
+ virtual HRESULT WINAPI HandleConfirmationOfOurCompareStates(DTCLUCOMPARESTATESCONFIRMATION Confirmation) = 0;
+ virtual HRESULT WINAPI HandleErrorFromOurCompareStates(DTCLUCOMPARESTATESERROR Error) = 0;
+ virtual HRESULT WINAPI ConversationLost(void) = 0;
+ };
+#else
+ typedef struct IDtcLuRecoveryInitiatedByLuWorkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecoveryInitiatedByLuWork *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecoveryInitiatedByLuWork *This);
+ ULONG (WINAPI *Release)(IDtcLuRecoveryInitiatedByLuWork *This);
+ HRESULT (WINAPI *HandleTheirXln)(IDtcLuRecoveryInitiatedByLuWork *This,LONG lRecoverySeqNum,DTCLUXLN Xln,unsigned char *pRemoteLogName,DWORD cbRemoteLogName,unsigned char *pOurLogName,DWORD cbOurLogName,DWORD dwProtocol,DTCLUXLNRESPONSE *pResponse);
+ HRESULT (WINAPI *GetOurLogNameSize)(IDtcLuRecoveryInitiatedByLuWork *This,DWORD *pcbOurLogName);
+ HRESULT (WINAPI *GetOurXln)(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUXLN *pXln,unsigned char *pOurLogName,DWORD *pdwProtocol);
+ HRESULT (WINAPI *HandleConfirmationOfOurXln)(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUXLNCONFIRMATION Confirmation);
+ HRESULT (WINAPI *HandleTheirCompareStates)(IDtcLuRecoveryInitiatedByLuWork *This,unsigned char *pRemoteTransId,DWORD cbRemoteTransId,DTCLUCOMPARESTATE CompareState,DTCLUCOMPARESTATESRESPONSE *pResponse,DTCLUCOMPARESTATE *pCompareState);
+ HRESULT (WINAPI *HandleConfirmationOfOurCompareStates)(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUCOMPARESTATESCONFIRMATION Confirmation);
+ HRESULT (WINAPI *HandleErrorFromOurCompareStates)(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUCOMPARESTATESERROR Error);
+ HRESULT (WINAPI *ConversationLost)(IDtcLuRecoveryInitiatedByLuWork *This);
+ END_INTERFACE
+ } IDtcLuRecoveryInitiatedByLuWorkVtbl;
+ struct IDtcLuRecoveryInitiatedByLuWork {
+ CONST_VTBL struct IDtcLuRecoveryInitiatedByLuWorkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecoveryInitiatedByLuWork_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecoveryInitiatedByLuWork_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecoveryInitiatedByLuWork_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRecoveryInitiatedByLuWork_HandleTheirXln(This,lRecoverySeqNum,Xln,pRemoteLogName,cbRemoteLogName,pOurLogName,cbOurLogName,dwProtocol,pResponse) (This)->lpVtbl->HandleTheirXln(This,lRecoverySeqNum,Xln,pRemoteLogName,cbRemoteLogName,pOurLogName,cbOurLogName,dwProtocol,pResponse)
+#define IDtcLuRecoveryInitiatedByLuWork_GetOurLogNameSize(This,pcbOurLogName) (This)->lpVtbl->GetOurLogNameSize(This,pcbOurLogName)
+#define IDtcLuRecoveryInitiatedByLuWork_GetOurXln(This,pXln,pOurLogName,pdwProtocol) (This)->lpVtbl->GetOurXln(This,pXln,pOurLogName,pdwProtocol)
+#define IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurXln(This,Confirmation) (This)->lpVtbl->HandleConfirmationOfOurXln(This,Confirmation)
+#define IDtcLuRecoveryInitiatedByLuWork_HandleTheirCompareStates(This,pRemoteTransId,cbRemoteTransId,CompareState,pResponse,pCompareState) (This)->lpVtbl->HandleTheirCompareStates(This,pRemoteTransId,cbRemoteTransId,CompareState,pResponse,pCompareState)
+#define IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurCompareStates(This,Confirmation) (This)->lpVtbl->HandleConfirmationOfOurCompareStates(This,Confirmation)
+#define IDtcLuRecoveryInitiatedByLuWork_HandleErrorFromOurCompareStates(This,Error) (This)->lpVtbl->HandleErrorFromOurCompareStates(This,Error)
+#define IDtcLuRecoveryInitiatedByLuWork_ConversationLost(This) (This)->lpVtbl->ConversationLost(This)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_HandleTheirXln_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,LONG lRecoverySeqNum,DTCLUXLN Xln,unsigned char *pRemoteLogName,DWORD cbRemoteLogName,unsigned char *pOurLogName,DWORD cbOurLogName,DWORD dwProtocol,DTCLUXLNRESPONSE *pResponse);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_HandleTheirXln_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_GetOurLogNameSize_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,DWORD *pcbOurLogName);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_GetOurLogNameSize_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_GetOurXln_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUXLN *pXln,unsigned char *pOurLogName,DWORD *pdwProtocol);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_GetOurXln_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurXln_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUXLNCONFIRMATION Confirmation);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurXln_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_HandleTheirCompareStates_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,unsigned char *pRemoteTransId,DWORD cbRemoteTransId,DTCLUCOMPARESTATE CompareState,DTCLUCOMPARESTATESRESPONSE *pResponse,DTCLUCOMPARESTATE *pCompareState);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_HandleTheirCompareStates_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurCompareStates_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUCOMPARESTATESCONFIRMATION Confirmation);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_HandleConfirmationOfOurCompareStates_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_HandleErrorFromOurCompareStates_Proxy(IDtcLuRecoveryInitiatedByLuWork *This,DTCLUCOMPARESTATESERROR Error);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_HandleErrorFromOurCompareStates_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLuWork_ConversationLost_Proxy(IDtcLuRecoveryInitiatedByLuWork *This);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLuWork_ConversationLost_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRecoveryInitiatedByLu_INTERFACE_DEFINED__
+#define __IDtcLuRecoveryInitiatedByLu_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRecoveryInitiatedByLu;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRecoveryInitiatedByLu : public IUnknown {
+ public:
+ virtual HRESULT WINAPI GetObjectToHandleWorkFromLu(IDtcLuRecoveryInitiatedByLuWork **ppWork) = 0;
+ };
+#else
+ typedef struct IDtcLuRecoveryInitiatedByLuVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRecoveryInitiatedByLu *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRecoveryInitiatedByLu *This);
+ ULONG (WINAPI *Release)(IDtcLuRecoveryInitiatedByLu *This);
+ HRESULT (WINAPI *GetObjectToHandleWorkFromLu)(IDtcLuRecoveryInitiatedByLu *This,IDtcLuRecoveryInitiatedByLuWork **ppWork);
+ END_INTERFACE
+ } IDtcLuRecoveryInitiatedByLuVtbl;
+ struct IDtcLuRecoveryInitiatedByLu {
+ CONST_VTBL struct IDtcLuRecoveryInitiatedByLuVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRecoveryInitiatedByLu_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRecoveryInitiatedByLu_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRecoveryInitiatedByLu_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRecoveryInitiatedByLu_GetObjectToHandleWorkFromLu(This,ppWork) (This)->lpVtbl->GetObjectToHandleWorkFromLu(This,ppWork)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRecoveryInitiatedByLu_GetObjectToHandleWorkFromLu_Proxy(IDtcLuRecoveryInitiatedByLu *This,IDtcLuRecoveryInitiatedByLuWork **ppWork);
+ void __RPC_STUB IDtcLuRecoveryInitiatedByLu_GetObjectToHandleWorkFromLu_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRmEnlistment_INTERFACE_DEFINED__
+#define __IDtcLuRmEnlistment_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRmEnlistment;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRmEnlistment : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Unplug(BOOL fConversationLost) = 0;
+ virtual HRESULT WINAPI BackedOut(void) = 0;
+ virtual HRESULT WINAPI BackOut(void) = 0;
+ virtual HRESULT WINAPI Committed(void) = 0;
+ virtual HRESULT WINAPI Forget(void) = 0;
+ virtual HRESULT WINAPI RequestCommit(void) = 0;
+ };
+#else
+ typedef struct IDtcLuRmEnlistmentVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRmEnlistment *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRmEnlistment *This);
+ ULONG (WINAPI *Release)(IDtcLuRmEnlistment *This);
+ HRESULT (WINAPI *Unplug)(IDtcLuRmEnlistment *This,BOOL fConversationLost);
+ HRESULT (WINAPI *BackedOut)(IDtcLuRmEnlistment *This);
+ HRESULT (WINAPI *BackOut)(IDtcLuRmEnlistment *This);
+ HRESULT (WINAPI *Committed)(IDtcLuRmEnlistment *This);
+ HRESULT (WINAPI *Forget)(IDtcLuRmEnlistment *This);
+ HRESULT (WINAPI *RequestCommit)(IDtcLuRmEnlistment *This);
+ END_INTERFACE
+ } IDtcLuRmEnlistmentVtbl;
+ struct IDtcLuRmEnlistment {
+ CONST_VTBL struct IDtcLuRmEnlistmentVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRmEnlistment_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRmEnlistment_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRmEnlistment_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRmEnlistment_Unplug(This,fConversationLost) (This)->lpVtbl->Unplug(This,fConversationLost)
+#define IDtcLuRmEnlistment_BackedOut(This) (This)->lpVtbl->BackedOut(This)
+#define IDtcLuRmEnlistment_BackOut(This) (This)->lpVtbl->BackOut(This)
+#define IDtcLuRmEnlistment_Committed(This) (This)->lpVtbl->Committed(This)
+#define IDtcLuRmEnlistment_Forget(This) (This)->lpVtbl->Forget(This)
+#define IDtcLuRmEnlistment_RequestCommit(This) (This)->lpVtbl->RequestCommit(This)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRmEnlistment_Unplug_Proxy(IDtcLuRmEnlistment *This,BOOL fConversationLost);
+ void __RPC_STUB IDtcLuRmEnlistment_Unplug_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistment_BackedOut_Proxy(IDtcLuRmEnlistment *This);
+ void __RPC_STUB IDtcLuRmEnlistment_BackedOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistment_BackOut_Proxy(IDtcLuRmEnlistment *This);
+ void __RPC_STUB IDtcLuRmEnlistment_BackOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistment_Committed_Proxy(IDtcLuRmEnlistment *This);
+ void __RPC_STUB IDtcLuRmEnlistment_Committed_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistment_Forget_Proxy(IDtcLuRmEnlistment *This);
+ void __RPC_STUB IDtcLuRmEnlistment_Forget_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistment_RequestCommit_Proxy(IDtcLuRmEnlistment *This);
+ void __RPC_STUB IDtcLuRmEnlistment_RequestCommit_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRmEnlistmentSink_INTERFACE_DEFINED__
+#define __IDtcLuRmEnlistmentSink_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRmEnlistmentSink;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRmEnlistmentSink : public IUnknown {
+ public:
+ virtual HRESULT WINAPI AckUnplug(void) = 0;
+ virtual HRESULT WINAPI TmDown(void) = 0;
+ virtual HRESULT WINAPI SessionLost(void) = 0;
+ virtual HRESULT WINAPI BackedOut(void) = 0;
+ virtual HRESULT WINAPI BackOut(void) = 0;
+ virtual HRESULT WINAPI Committed(void) = 0;
+ virtual HRESULT WINAPI Forget(void) = 0;
+ virtual HRESULT WINAPI Prepare(void) = 0;
+ virtual HRESULT WINAPI RequestCommit(void) = 0;
+ };
+#else
+ typedef struct IDtcLuRmEnlistmentSinkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRmEnlistmentSink *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRmEnlistmentSink *This);
+ ULONG (WINAPI *Release)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *AckUnplug)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *TmDown)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *SessionLost)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *BackedOut)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *BackOut)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *Committed)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *Forget)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *Prepare)(IDtcLuRmEnlistmentSink *This);
+ HRESULT (WINAPI *RequestCommit)(IDtcLuRmEnlistmentSink *This);
+ END_INTERFACE
+ } IDtcLuRmEnlistmentSinkVtbl;
+ struct IDtcLuRmEnlistmentSink {
+ CONST_VTBL struct IDtcLuRmEnlistmentSinkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRmEnlistmentSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRmEnlistmentSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRmEnlistmentSink_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRmEnlistmentSink_AckUnplug(This) (This)->lpVtbl->AckUnplug(This)
+#define IDtcLuRmEnlistmentSink_TmDown(This) (This)->lpVtbl->TmDown(This)
+#define IDtcLuRmEnlistmentSink_SessionLost(This) (This)->lpVtbl->SessionLost(This)
+#define IDtcLuRmEnlistmentSink_BackedOut(This) (This)->lpVtbl->BackedOut(This)
+#define IDtcLuRmEnlistmentSink_BackOut(This) (This)->lpVtbl->BackOut(This)
+#define IDtcLuRmEnlistmentSink_Committed(This) (This)->lpVtbl->Committed(This)
+#define IDtcLuRmEnlistmentSink_Forget(This) (This)->lpVtbl->Forget(This)
+#define IDtcLuRmEnlistmentSink_Prepare(This) (This)->lpVtbl->Prepare(This)
+#define IDtcLuRmEnlistmentSink_RequestCommit(This) (This)->lpVtbl->RequestCommit(This)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_AckUnplug_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_AckUnplug_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_TmDown_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_TmDown_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_SessionLost_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_SessionLost_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_BackedOut_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_BackedOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_BackOut_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_BackOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_Committed_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_Committed_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_Forget_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_Forget_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_Prepare_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_Prepare_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuRmEnlistmentSink_RequestCommit_Proxy(IDtcLuRmEnlistmentSink *This);
+ void __RPC_STUB IDtcLuRmEnlistmentSink_RequestCommit_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuRmEnlistmentFactory_INTERFACE_DEFINED__
+#define __IDtcLuRmEnlistmentFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuRmEnlistmentFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuRmEnlistmentFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(unsigned char *pucLuPair,DWORD cbLuPair,ITransaction *pITransaction,unsigned char *pTransId,DWORD cbTransId,IDtcLuRmEnlistmentSink *pRmEnlistmentSink,IDtcLuRmEnlistment **ppRmEnlistment) = 0;
+ };
+#else
+ typedef struct IDtcLuRmEnlistmentFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuRmEnlistmentFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuRmEnlistmentFactory *This);
+ ULONG (WINAPI *Release)(IDtcLuRmEnlistmentFactory *This);
+ HRESULT (WINAPI *Create)(IDtcLuRmEnlistmentFactory *This,unsigned char *pucLuPair,DWORD cbLuPair,ITransaction *pITransaction,unsigned char *pTransId,DWORD cbTransId,IDtcLuRmEnlistmentSink *pRmEnlistmentSink,IDtcLuRmEnlistment **ppRmEnlistment);
+ END_INTERFACE
+ } IDtcLuRmEnlistmentFactoryVtbl;
+ struct IDtcLuRmEnlistmentFactory {
+ CONST_VTBL struct IDtcLuRmEnlistmentFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuRmEnlistmentFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuRmEnlistmentFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuRmEnlistmentFactory_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuRmEnlistmentFactory_Create(This,pucLuPair,cbLuPair,pITransaction,pTransId,cbTransId,pRmEnlistmentSink,ppRmEnlistment) (This)->lpVtbl->Create(This,pucLuPair,cbLuPair,pITransaction,pTransId,cbTransId,pRmEnlistmentSink,ppRmEnlistment)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuRmEnlistmentFactory_Create_Proxy(IDtcLuRmEnlistmentFactory *This,unsigned char *pucLuPair,DWORD cbLuPair,ITransaction *pITransaction,unsigned char *pTransId,DWORD cbTransId,IDtcLuRmEnlistmentSink *pRmEnlistmentSink,IDtcLuRmEnlistment **ppRmEnlistment);
+ void __RPC_STUB IDtcLuRmEnlistmentFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuSubordinateDtc_INTERFACE_DEFINED__
+#define __IDtcLuSubordinateDtc_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuSubordinateDtc;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuSubordinateDtc : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Unplug(BOOL fConversationLost) = 0;
+ virtual HRESULT WINAPI BackedOut(void) = 0;
+ virtual HRESULT WINAPI BackOut(void) = 0;
+ virtual HRESULT WINAPI Committed(void) = 0;
+ virtual HRESULT WINAPI Forget(void) = 0;
+ virtual HRESULT WINAPI Prepare(void) = 0;
+ virtual HRESULT WINAPI RequestCommit(void) = 0;
+ };
+#else
+ typedef struct IDtcLuSubordinateDtcVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuSubordinateDtc *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuSubordinateDtc *This);
+ ULONG (WINAPI *Release)(IDtcLuSubordinateDtc *This);
+ HRESULT (WINAPI *Unplug)(IDtcLuSubordinateDtc *This,BOOL fConversationLost);
+ HRESULT (WINAPI *BackedOut)(IDtcLuSubordinateDtc *This);
+ HRESULT (WINAPI *BackOut)(IDtcLuSubordinateDtc *This);
+ HRESULT (WINAPI *Committed)(IDtcLuSubordinateDtc *This);
+ HRESULT (WINAPI *Forget)(IDtcLuSubordinateDtc *This);
+ HRESULT (WINAPI *Prepare)(IDtcLuSubordinateDtc *This);
+ HRESULT (WINAPI *RequestCommit)(IDtcLuSubordinateDtc *This);
+ END_INTERFACE
+ } IDtcLuSubordinateDtcVtbl;
+ struct IDtcLuSubordinateDtc {
+ CONST_VTBL struct IDtcLuSubordinateDtcVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuSubordinateDtc_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuSubordinateDtc_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuSubordinateDtc_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuSubordinateDtc_Unplug(This,fConversationLost) (This)->lpVtbl->Unplug(This,fConversationLost)
+#define IDtcLuSubordinateDtc_BackedOut(This) (This)->lpVtbl->BackedOut(This)
+#define IDtcLuSubordinateDtc_BackOut(This) (This)->lpVtbl->BackOut(This)
+#define IDtcLuSubordinateDtc_Committed(This) (This)->lpVtbl->Committed(This)
+#define IDtcLuSubordinateDtc_Forget(This) (This)->lpVtbl->Forget(This)
+#define IDtcLuSubordinateDtc_Prepare(This) (This)->lpVtbl->Prepare(This)
+#define IDtcLuSubordinateDtc_RequestCommit(This) (This)->lpVtbl->RequestCommit(This)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuSubordinateDtc_Unplug_Proxy(IDtcLuSubordinateDtc *This,BOOL fConversationLost);
+ void __RPC_STUB IDtcLuSubordinateDtc_Unplug_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtc_BackedOut_Proxy(IDtcLuSubordinateDtc *This);
+ void __RPC_STUB IDtcLuSubordinateDtc_BackedOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtc_BackOut_Proxy(IDtcLuSubordinateDtc *This);
+ void __RPC_STUB IDtcLuSubordinateDtc_BackOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtc_Committed_Proxy(IDtcLuSubordinateDtc *This);
+ void __RPC_STUB IDtcLuSubordinateDtc_Committed_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtc_Forget_Proxy(IDtcLuSubordinateDtc *This);
+ void __RPC_STUB IDtcLuSubordinateDtc_Forget_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtc_Prepare_Proxy(IDtcLuSubordinateDtc *This);
+ void __RPC_STUB IDtcLuSubordinateDtc_Prepare_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtc_RequestCommit_Proxy(IDtcLuSubordinateDtc *This);
+ void __RPC_STUB IDtcLuSubordinateDtc_RequestCommit_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuSubordinateDtcSink_INTERFACE_DEFINED__
+#define __IDtcLuSubordinateDtcSink_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuSubordinateDtcSink;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuSubordinateDtcSink : public IUnknown {
+ public:
+ virtual HRESULT WINAPI AckUnplug(void) = 0;
+ virtual HRESULT WINAPI TmDown(void) = 0;
+ virtual HRESULT WINAPI SessionLost(void) = 0;
+ virtual HRESULT WINAPI BackedOut(void) = 0;
+ virtual HRESULT WINAPI BackOut(void) = 0;
+ virtual HRESULT WINAPI Committed(void) = 0;
+ virtual HRESULT WINAPI Forget(void) = 0;
+ virtual HRESULT WINAPI RequestCommit(void) = 0;
+ };
+#else
+ typedef struct IDtcLuSubordinateDtcSinkVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuSubordinateDtcSink *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuSubordinateDtcSink *This);
+ ULONG (WINAPI *Release)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *AckUnplug)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *TmDown)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *SessionLost)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *BackedOut)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *BackOut)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *Committed)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *Forget)(IDtcLuSubordinateDtcSink *This);
+ HRESULT (WINAPI *RequestCommit)(IDtcLuSubordinateDtcSink *This);
+ END_INTERFACE
+ } IDtcLuSubordinateDtcSinkVtbl;
+ struct IDtcLuSubordinateDtcSink {
+ CONST_VTBL struct IDtcLuSubordinateDtcSinkVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuSubordinateDtcSink_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuSubordinateDtcSink_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuSubordinateDtcSink_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuSubordinateDtcSink_AckUnplug(This) (This)->lpVtbl->AckUnplug(This)
+#define IDtcLuSubordinateDtcSink_TmDown(This) (This)->lpVtbl->TmDown(This)
+#define IDtcLuSubordinateDtcSink_SessionLost(This) (This)->lpVtbl->SessionLost(This)
+#define IDtcLuSubordinateDtcSink_BackedOut(This) (This)->lpVtbl->BackedOut(This)
+#define IDtcLuSubordinateDtcSink_BackOut(This) (This)->lpVtbl->BackOut(This)
+#define IDtcLuSubordinateDtcSink_Committed(This) (This)->lpVtbl->Committed(This)
+#define IDtcLuSubordinateDtcSink_Forget(This) (This)->lpVtbl->Forget(This)
+#define IDtcLuSubordinateDtcSink_RequestCommit(This) (This)->lpVtbl->RequestCommit(This)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_AckUnplug_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_AckUnplug_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_TmDown_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_TmDown_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_SessionLost_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_SessionLost_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_BackedOut_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_BackedOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_BackOut_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_BackOut_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_Committed_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_Committed_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_Forget_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_Forget_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+ HRESULT WINAPI IDtcLuSubordinateDtcSink_RequestCommit_Proxy(IDtcLuSubordinateDtcSink *This);
+ void __RPC_STUB IDtcLuSubordinateDtcSink_RequestCommit_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+#ifndef __IDtcLuSubordinateDtcFactory_INTERFACE_DEFINED__
+#define __IDtcLuSubordinateDtcFactory_INTERFACE_DEFINED__
+ EXTERN_C const IID IID_IDtcLuSubordinateDtcFactory;
+#if defined(__cplusplus) && !defined(CINTERFACE)
+ struct IDtcLuSubordinateDtcFactory : public IUnknown {
+ public:
+ virtual HRESULT WINAPI Create(unsigned char *pucLuPair,DWORD cbLuPair,IUnknown *punkTransactionOuter,ISOLEVEL isoLevel,ULONG isoFlags,ITransactionOptions *pOptions,ITransaction **ppTransaction,unsigned char *pTransId,DWORD cbTransId,IDtcLuSubordinateDtcSink *pSubordinateDtcSink,IDtcLuSubordinateDtc **ppSubordinateDtc) = 0;
+ };
+#else
+ typedef struct IDtcLuSubordinateDtcFactoryVtbl {
+ BEGIN_INTERFACE
+ HRESULT (WINAPI *QueryInterface)(IDtcLuSubordinateDtcFactory *This,REFIID riid,void **ppvObject);
+ ULONG (WINAPI *AddRef)(IDtcLuSubordinateDtcFactory *This);
+ ULONG (WINAPI *Release)(IDtcLuSubordinateDtcFactory *This);
+ HRESULT (WINAPI *Create)(IDtcLuSubordinateDtcFactory *This,unsigned char *pucLuPair,DWORD cbLuPair,IUnknown *punkTransactionOuter,ISOLEVEL isoLevel,ULONG isoFlags,ITransactionOptions *pOptions,ITransaction **ppTransaction,unsigned char *pTransId,DWORD cbTransId,IDtcLuSubordinateDtcSink *pSubordinateDtcSink,IDtcLuSubordinateDtc **ppSubordinateDtc);
+ END_INTERFACE
+ } IDtcLuSubordinateDtcFactoryVtbl;
+ struct IDtcLuSubordinateDtcFactory {
+ CONST_VTBL struct IDtcLuSubordinateDtcFactoryVtbl *lpVtbl;
+ };
+#ifdef COBJMACROS
+#define IDtcLuSubordinateDtcFactory_QueryInterface(This,riid,ppvObject) (This)->lpVtbl->QueryInterface(This,riid,ppvObject)
+#define IDtcLuSubordinateDtcFactory_AddRef(This) (This)->lpVtbl->AddRef(This)
+#define IDtcLuSubordinateDtcFactory_Release(This) (This)->lpVtbl->Release(This)
+#define IDtcLuSubordinateDtcFactory_Create(This,pucLuPair,cbLuPair,punkTransactionOuter,isoLevel,isoFlags,pOptions,ppTransaction,pTransId,cbTransId,pSubordinateDtcSink,ppSubordinateDtc) (This)->lpVtbl->Create(This,pucLuPair,cbLuPair,punkTransactionOuter,isoLevel,isoFlags,pOptions,ppTransaction,pTransId,cbTransId,pSubordinateDtcSink,ppSubordinateDtc)
+#endif
+#endif
+ HRESULT WINAPI IDtcLuSubordinateDtcFactory_Create_Proxy(IDtcLuSubordinateDtcFactory *This,unsigned char *pucLuPair,DWORD cbLuPair,IUnknown *punkTransactionOuter,ISOLEVEL isoLevel,ULONG isoFlags,ITransactionOptions *pOptions,ITransaction **ppTransaction,unsigned char *pTransId,DWORD cbTransId,IDtcLuSubordinateDtcSink *pSubordinateDtcSink,IDtcLuSubordinateDtc **ppSubordinateDtc);
+ void __RPC_STUB IDtcLuSubordinateDtcFactory_Create_Stub(IRpcStubBuffer *This,IRpcChannelBuffer *_pRpcChannelBuffer,PRPC_MESSAGE _pRpcMessage,DWORD *_pdwStubPhase);
+#endif
+
+ DEFINE_GUID(IID_IXATransLookup,0xF3B1F131,0xEEDA,0x11ce,0xAE,0xD4,0x00,0xAA,0x00,0x51,0xE2,0xC4);
+ DEFINE_GUID(IID_IXATransLookup2,0xbf193c85,0xd1a,0x4290,0xb8,0x8f,0xd2,0xcb,0x88,0x73,0xd1,0xe7);
+ DEFINE_GUID(IID_IResourceManagerSink,0x0D563181,0xDEFB,0x11ce,0xAE,0xD1,0x00,0xAA,0x00,0x51,0xE2,0xC4);
+ DEFINE_GUID(IID_IResourceManager,0x3741d21,0x87eb,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e);
+ DEFINE_GUID(IID_IResourceManager2,0xd136c69a,0xf749,0x11d1,0x8f,0x47,0x0,0xc0,0x4f,0x8e,0xe5,0x7d);
+ DEFINE_GUID(IID_ILastResourceManager,0x4d964ad4,0x5b33,0x11d3,0x8a,0x91,0x00,0xc0,0x4f,0x79,0xeb,0x6d);
+ DEFINE_GUID(IID_IXAConfig,0xC8A6E3A1,0x9A8C,0x11cf,0xA3,0x08,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IRMHelper,0xE793F6D1,0xF53D,0x11cf,0xA6,0x0D,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IXAObtainRMInfo,0xE793F6D2,0xF53D,0x11cf,0xA6,0x0D,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IXAResourceManager,0x4131E751,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IXAResourceManagerFactory,0x4131E750,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IXATransaction,0x4131E752,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IResourceManagerFactory,0x13741d20,0x87eb,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e);
+ DEFINE_GUID(IID_IResourceManagerFactory2,0x6b369c21,0xfbd2,0x11d1,0x8f,0x47,0x0,0xc0,0x4f,0x8e,0xe5,0x7d);
+ DEFINE_GUID(IID_IPrepareInfo,0x80c7bfd0,0x87ee,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e);
+ DEFINE_GUID(IID_IPrepareInfo2,0x5FAB2547,0x9779,0x11d1,0xB8,0x86,0x00,0xC0,0x4F,0xB9,0x61,0x8A);
+ DEFINE_GUID(IID_IGetDispenser,0xc23cc370,0x87ef,0x11ce,0x80,0x81,0x00,0x80,0xc7,0x58,0x52,0x7e);
+ DEFINE_GUID(IID_ITransactionVoterNotifyAsync2,0x5433376b,0x414d,0x11d3,0xb2,0x6,0x0,0xc0,0x4f,0xc2,0xf3,0xef);
+ DEFINE_GUID(IID_ITransactionVoterBallotAsync2,0x5433376c,0x414d,0x11d3,0xb2,0x6,0x0,0xc0,0x4f,0xc2,0xf3,0xef);
+ DEFINE_GUID(IID_ITransactionVoterFactory2,0x5433376a,0x414d,0x11d3,0xb2,0x6,0x0,0xc0,0x4f,0xc2,0xf3,0xef);
+ DEFINE_GUID(IID_ITransactionPhase0EnlistmentAsync,0x82DC88E1,0xA954,0x11d1,0x8F,0x88,0x00,0x60,0x08,0x95,0xE7,0xD5);
+ DEFINE_GUID(IID_ITransactionPhase0NotifyAsync,0xEF081809,0x0C76,0x11d2,0x87,0xA6,0x00,0xC0,0x4F,0x99,0x0F,0x34);
+ DEFINE_GUID(IID_ITransactionPhase0Factory,0x82DC88E0,0xA954,0x11d1,0x8F,0x88,0x00,0x60,0x08,0x95,0xE7,0xD5);
+ DEFINE_GUID(IID_ITransactionTransmitter,0x59313E01,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3);
+ DEFINE_GUID(IID_ITransactionTransmitterFactory,0x59313E00,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3);
+ DEFINE_GUID(IID_ITransactionReceiver,0x59313E03,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3);
+ DEFINE_GUID(IID_ITransactionReceiverFactory,0x59313E02,0xB36C,0x11cf,0xA5,0x39,0x00,0xAA,0x00,0x68,0x87,0xC3);
+ DEFINE_GUID(IID_IDtcLuConfigure,0x4131E760,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRecovery,0xac2b8ad2,0xd6f0,0x11d0,0xb3,0x86,0x0,0xa0,0xc9,0x8,0x33,0x65);
+ DEFINE_GUID(IID_IDtcLuRecoveryFactory,0x4131E762,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRecoveryInitiatedByDtcTransWork,0x4131E765,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRecoveryInitiatedByDtcStatusWork,0x4131E766,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRecoveryInitiatedByDtc,0x4131E764,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRecoveryInitiatedByLuWork,0xac2b8ad1,0xd6f0,0x11d0,0xb3,0x86,0x0,0xa0,0xc9,0x8,0x33,0x65);
+ DEFINE_GUID(IID_IDtcLuRecoveryInitiatedByLu,0x4131E768,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRmEnlistment,0x4131E769,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRmEnlistmentSink,0x4131E770,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuRmEnlistmentFactory,0x4131E771,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuSubordinateDtc,0x4131E773,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuSubordinateDtcSink,0x4131E774,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+ DEFINE_GUID(IID_IDtcLuSubordinateDtcFactory,0x4131E775,0x1AEA,0x11d0,0x94,0x4B,0x00,0xA0,0xC9,0x05,0x41,0x6E);
+
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0155_v0_0_c_ifspec;
+ extern RPC_IF_HANDLE __MIDL_itf_txdtc_0155_v0_0_s_ifspec;
+
+#ifdef __cplusplus
+}
+#endif
+#endif
--
1.7.5.4
More information about the wine-patches
mailing list