dlls/xolehlp/xolehlp.c

   1 /*
   2  * Copyright 2011 Hans Leidekker for CodeWeavers
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <stdarg.h>
  20 #define COBJMACROS
  21 #include "windef.h"
  22 #include "winbase.h"
  23 #include "transact.h"
  24 #include "initguid.h"
  25 #include "txdtc.h"
  26 #include "wine/debug.h"
  27
  28 WINE_DEFAULT_DEBUG_CHANNEL(xolehlp);
  29
  30 /* Resource manager start */
  31
  32 typedef struct {
  33     IResourceManager IResourceManager_iface;
  34     LONG ref;
  35 } ResourceManager;
  36
  37 static inline ResourceManager *impl_from_IResourceManager(IResourceManager *iface)
  38 {
  39     return CONTAINING_RECORD(iface, ResourceManager, IResourceManager_iface);
  40 }
  41
  42 static HRESULT WINAPI ResourceManager_QueryInterface(IResourceManager *iface, REFIID iid,
  43     void **ppv)
  44 {
  45     ResourceManager *This = impl_from_IResourceManager(iface);
  46     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
  47
  48     if (!ppv) return E_INVALIDARG;
  49
  50     if (IsEqualIID(&IID_IUnknown, iid) ||
  51         IsEqualIID(&IID_IResourceManager, iid))
  52     {
  53         *ppv = &This->IResourceManager_iface;
  54     }
  55     else
  56     {
  57         FIXME("(%s): not implemented\n", debugstr_guid(iid));
  58         *ppv = NULL;
  59         return E_NOINTERFACE;
  60     }
  61
  62     IUnknown_AddRef((IUnknown*)*ppv);
  63     return S_OK;
  64 }
  65
  66 static ULONG WINAPI ResourceManager_AddRef(IResourceManager *iface)
  67 {
  68     ResourceManager *This = impl_from_IResourceManager(iface);
  69     ULONG ref = InterlockedIncrement(&This->ref);
  70
  71     TRACE("(%p) refcount=%lu\n", iface, ref);
  72
  73     return ref;
  74 }
  75
  76 static ULONG WINAPI ResourceManager_Release(IResourceManager *iface)
  77 {
  78     ResourceManager *This = impl_from_IResourceManager(iface);
  79     ULONG ref = InterlockedDecrement(&This->ref);
  80
  81     TRACE("(%p) refcount=%lu\n", iface, ref);
  82
  83     if (ref == 0)
  84     {
  85         free(This);
  86     }
  87
  88     return ref;
  89 }
  90 static HRESULT WINAPI ResourceManager_Enlist(IResourceManager *iface,
  91         ITransaction *pTransaction,ITransactionResourceAsync *pRes,XACTUOW *pUOW,
  92         LONG *pisoLevel,ITransactionEnlistmentAsync **ppEnlist)
  93 {
  94     FIXME("(%p, %p, %p, %p, %p, %p): stub\n", iface, pTransaction,pRes,pUOW,
  95         pisoLevel,ppEnlist);
  96     return E_NOTIMPL;
  97 }
  98 static HRESULT WINAPI ResourceManager_Reenlist(IResourceManager *iface,
  99         byte *pPrepInfo,ULONG cbPrepInfo,DWORD lTimeout,XACTSTAT *pXactStat)
 100 {
 101     FIXME("(%p, %p, %lu, %lu, %p): stub\n", iface, pPrepInfo, cbPrepInfo, lTimeout, pXactStat);
 102     return E_NOTIMPL;
 103 }
 104 static HRESULT WINAPI ResourceManager_ReenlistmentComplete(IResourceManager *iface)
 105 {
 106     FIXME("(%p): stub\n", iface);
 107     return S_OK;
 108 }
 109 static HRESULT WINAPI ResourceManager_GetDistributedTransactionManager(IResourceManager *iface,
 110         REFIID iid,void **ppvObject)
 111 {
 112     FIXME("(%p, %s, %p): stub\n", iface, debugstr_guid(iid), ppvObject);
 113     return E_NOTIMPL;
 114 }
 115
 116 static const IResourceManagerVtbl ResourceManager_Vtbl = {
 117     ResourceManager_QueryInterface,
 118     ResourceManager_AddRef,
 119     ResourceManager_Release,
 120     ResourceManager_Enlist,
 121     ResourceManager_Reenlist,
 122     ResourceManager_ReenlistmentComplete,
 123     ResourceManager_GetDistributedTransactionManager
 124 };
 125
 126 static HRESULT ResourceManager_Create(REFIID riid, void **ppv)
 127 {
 128     ResourceManager *This;
 129     HRESULT ret;
 130
 131     if (!ppv) return E_INVALIDARG;
 132
 133     This = malloc(sizeof(*This));
 134     if (!This) return E_OUTOFMEMORY;
 135
 136     This->IResourceManager_iface.lpVtbl = &ResourceManager_Vtbl;
 137     This->ref = 1;
 138
 139     ret = IResourceManager_QueryInterface(&This->IResourceManager_iface, riid, ppv);
 140     IResourceManager_Release(&This->IResourceManager_iface);
 141
 142     return ret;
 143 }
 144
 145 /* Resource manager end */
 146
 147 /* Transaction options start */
 148
 149 typedef struct {
 150     ITransactionOptions ITransactionOptions_iface;
 151     LONG ref;
 152     XACTOPT opts;
 153 } TransactionOptions;
 154
 155 static inline TransactionOptions *impl_from_ITransactionOptions(ITransactionOptions *iface)
 156 {
 157     return CONTAINING_RECORD(iface, TransactionOptions, ITransactionOptions_iface);
 158 }
 159
 160 static HRESULT WINAPI TransactionOptions_QueryInterface(ITransactionOptions *iface, REFIID iid,
 161     void **ppv)
 162 {
 163     TransactionOptions *This = impl_from_ITransactionOptions(iface);
 164     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 165
 166     if (!ppv) return E_INVALIDARG;
 167
 168     if (IsEqualIID(&IID_IUnknown, iid) ||
 169         IsEqualIID(&IID_ITransactionOptions, iid))
 170     {
 171         *ppv = &This->ITransactionOptions_iface;
 172     }
 173     else
 174     {
 175         FIXME("(%s): not implemented\n", debugstr_guid(iid));
 176         *ppv = NULL;
 177         return E_NOINTERFACE;
 178     }
 179
 180     IUnknown_AddRef((IUnknown*)*ppv);
 181     return S_OK;
 182 }
 183
 184 static ULONG WINAPI TransactionOptions_AddRef(ITransactionOptions *iface)
 185 {
 186     TransactionOptions *This = impl_from_ITransactionOptions(iface);
 187     ULONG ref = InterlockedIncrement(&This->ref);
 188
 189     TRACE("(%p) refcount=%lu\n", iface, ref);
 190
 191     return ref;
 192 }
 193
 194 static ULONG WINAPI TransactionOptions_Release(ITransactionOptions *iface)
 195 {
 196     TransactionOptions *This = impl_from_ITransactionOptions(iface);
 197     ULONG ref = InterlockedDecrement(&This->ref);
 198
 199     TRACE("(%p) refcount=%lu\n", iface, ref);
 200
 201     if (ref == 0)
 202     {
 203         free(This);
 204     }
 205
 206     return ref;
 207 }
 208 static HRESULT WINAPI TransactionOptions_SetOptions(ITransactionOptions *iface,
 209     XACTOPT *pOptions)
 210 {
 211     TransactionOptions *This = impl_from_ITransactionOptions(iface);
 212
 213     if (!pOptions) return E_INVALIDARG;
 214     TRACE("(%p, %lu, %s)\n", iface, pOptions->ulTimeout, debugstr_a(pOptions->szDescription));
 215     This->opts = *pOptions;
 216     return S_OK;
 217 }
 218 static HRESULT WINAPI TransactionOptions_GetOptions(ITransactionOptions *iface,
 219     XACTOPT *pOptions)
 220 {
 221     TransactionOptions *This = impl_from_ITransactionOptions(iface);
 222
 223     TRACE("(%p, %p)\n", iface, pOptions);
 224     if (!pOptions) return E_INVALIDARG;
 225     *pOptions = This->opts;
 226     return S_OK;
 227 }
 228
 229 static const ITransactionOptionsVtbl TransactionOptions_Vtbl = {
 230     TransactionOptions_QueryInterface,
 231     TransactionOptions_AddRef,
 232     TransactionOptions_Release,
 233     TransactionOptions_SetOptions,
 234     TransactionOptions_GetOptions
 235 };
 236
 237 static HRESULT TransactionOptions_Create(ITransactionOptions **ppv)
 238 {
 239     TransactionOptions *This;
 240
 241     if (!ppv) return E_INVALIDARG;
 242
 243     This = malloc(sizeof(*This));
 244     if (!This) return E_OUTOFMEMORY;
 245
 246     This->ITransactionOptions_iface.lpVtbl = &TransactionOptions_Vtbl;
 247     This->ref = 1;
 248
 249     *ppv = &This->ITransactionOptions_iface;
 250
 251     return S_OK;
 252 }
 253
 254 /* Transaction options end */
 255
 256 /* Transaction start */
 257
 258 typedef struct {
 259     ITransaction ITransaction_iface;
 260     LONG ref;
 261     XACTTRANSINFO info;
 262 } Transaction;
 263
 264 static inline Transaction *impl_from_ITransaction(ITransaction *iface)
 265 {
 266     return CONTAINING_RECORD(iface, Transaction, ITransaction_iface);
 267 }
 268
 269 static HRESULT WINAPI Transaction_QueryInterface(ITransaction *iface, REFIID iid,
 270     void **ppv)
 271 {
 272     Transaction *This = impl_from_ITransaction(iface);
 273     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 274
 275     if (!ppv) return E_INVALIDARG;
 276
 277     if (IsEqualIID(&IID_IUnknown, iid) ||
 278         IsEqualIID(&IID_ITransaction, iid))
 279     {
 280         *ppv = &This->ITransaction_iface;
 281     }
 282     else
 283     {
 284         FIXME("(%s): not implemented\n", debugstr_guid(iid));
 285         *ppv = NULL;
 286         return E_NOINTERFACE;
 287     }
 288
 289     IUnknown_AddRef((IUnknown*)*ppv);
 290     return S_OK;
 291 }
 292
 293 static ULONG WINAPI Transaction_AddRef(ITransaction *iface)
 294 {
 295     Transaction *This = impl_from_ITransaction(iface);
 296     ULONG ref = InterlockedIncrement(&This->ref);
 297
 298     TRACE("(%p) refcount=%lu\n", iface, ref);
 299
 300     return ref;
 301 }
 302
 303 static ULONG WINAPI Transaction_Release(ITransaction *iface)
 304 {
 305     Transaction *This = impl_from_ITransaction(iface);
 306     ULONG ref = InterlockedDecrement(&This->ref);
 307
 308     TRACE("(%p) refcount=%lu\n", iface, ref);
 309
 310     if (ref == 0)
 311     {
 312         free(This);
 313     }
 314
 315     return ref;
 316 }
 317 static HRESULT WINAPI Transaction_Commit(ITransaction *iface,
 318     BOOL fRetaining, DWORD grfTC, DWORD grfRM)
 319 {
 320     FIXME("(%p, %d, %08lx, %08lx): stub\n", iface, fRetaining, grfTC, grfRM);
 321     return E_NOTIMPL;
 322 }
 323 static HRESULT WINAPI Transaction_Abort(ITransaction *iface,
 324     BOID *pboidReason, BOOL fRetaining, BOOL fAsync)
 325 {
 326     FIXME("(%p, %p, %d, %d): stub\n", iface, pboidReason, fRetaining, fAsync);
 327     return E_NOTIMPL;
 328 }
 329 static HRESULT WINAPI Transaction_GetTransactionInfo(ITransaction *iface,
 330     XACTTRANSINFO *pinfo)
 331 {
 332     Transaction *This = impl_from_ITransaction(iface);
 333     TRACE("(%p, %p)\n", iface, pinfo);
 334     if (!pinfo) return E_INVALIDARG;
 335     *pinfo = This->info;
 336     return S_OK;
 337 }
 338
 339 static const ITransactionVtbl Transaction_Vtbl = {
 340     Transaction_QueryInterface,
 341     Transaction_AddRef,
 342     Transaction_Release,
 343     Transaction_Commit,
 344     Transaction_Abort,
 345     Transaction_GetTransactionInfo
 346 };
 347
 348 static HRESULT Transaction_Create(ISOLEVEL isoLevel, ULONG isoFlags,
 349         ITransactionOptions *pOptions, ITransaction **ppv)
 350 {
 351     Transaction *This;
 352
 353     if (!ppv) return E_INVALIDARG;
 354
 355     This = calloc(1, sizeof(*This));
 356     if (!This) return E_OUTOFMEMORY;
 357
 358     This->ITransaction_iface.lpVtbl = &Transaction_Vtbl;
 359     This->ref = 1;
 360     This->info.isoLevel = isoLevel;
 361     This->info.isoFlags = isoFlags;
 362
 363     *ppv = &This->ITransaction_iface;
 364
 365     return S_OK;
 366 }
 367
 368 /* Transaction end */
 369
 370 /* DTC Proxy Core Object start */
 371
 372 typedef struct {
 373     ITransactionDispenser ITransactionDispenser_iface;
 374     LONG ref;
 375     IResourceManagerFactory2 IResourceManagerFactory2_iface;
 376     ITransactionImportWhereabouts ITransactionImportWhereabouts_iface;
 377     ITransactionImport ITransactionImport_iface;
 378 } TransactionManager;
 379
 380 static inline TransactionManager *impl_from_ITransactionDispenser(ITransactionDispenser *iface)
 381 {
 382     return CONTAINING_RECORD(iface, TransactionManager, ITransactionDispenser_iface);
 383 }
 384
 385 static HRESULT WINAPI TransactionDispenser_QueryInterface(ITransactionDispenser *iface, REFIID iid,
 386     void **ppv)
 387 {
 388     TransactionManager *This = impl_from_ITransactionDispenser(iface);
 389     TRACE("(%p,%s,%p)\n", iface, debugstr_guid(iid), ppv);
 390
 391     if (!ppv) return E_INVALIDARG;
 392
 393     if (IsEqualIID(&IID_IUnknown, iid) ||
 394         IsEqualIID(&IID_ITransactionDispenser, iid))
 395     {
 396         *ppv = &This->ITransactionDispenser_iface;
 397     }
 398     else if (IsEqualIID(&IID_IResourceManagerFactory, iid) ||
 399         IsEqualIID(&IID_IResourceManagerFactory2, iid))
 400     {
 401         *ppv = &This->IResourceManagerFactory2_iface;
 402     }
 403     else if (IsEqualIID(&IID_ITransactionImportWhereabouts, iid))
 404     {
 405         *ppv = &This->ITransactionImportWhereabouts_iface;
 406     }
 407     else if (IsEqualIID(&IID_ITransactionImport, iid))
 408     {
 409         *ppv = &This->ITransactionImport_iface;
 410     }
 411     else
 412     {
 413         FIXME("(%s): not implemented\n", debugstr_guid(iid));
 414         *ppv = NULL;
 415         return E_NOINTERFACE;
 416     }
 417
 418     IUnknown_AddRef((IUnknown*)*ppv);
 419     return S_OK;
 420 }
 421
 422 static ULONG WINAPI TransactionDispenser_AddRef(ITransactionDispenser *iface)
 423 {
 424     TransactionManager *This = impl_from_ITransactionDispenser(iface);
 425     ULONG ref = InterlockedIncrement(&This->ref);
 426
 427     TRACE("(%p) refcount=%lu\n", iface, ref);
 428
 429     return ref;
 430 }
 431
 432 static ULONG WINAPI TransactionDispenser_Release(ITransactionDispenser *iface)
 433 {
 434     TransactionManager *This = impl_from_ITransactionDispenser(iface);
 435     ULONG ref = InterlockedDecrement(&This->ref);
 436
 437     TRACE("(%p) refcount=%lu\n", iface, ref);
 438
 439     if (ref == 0)
 440     {
 441         free(This);
 442     }
 443
 444     return ref;
 445 }
 446
 447 static HRESULT WINAPI TransactionDispenser_GetOptionsObject(ITransactionDispenser *iface,
 448         ITransactionOptions **ppOptions)
 449 {
 450     TRACE("(%p, %p)\n", iface, ppOptions);
 451
 452     if (!ppOptions) return E_INVALIDARG;
 453     return TransactionOptions_Create(ppOptions);
 454 }
 455 static HRESULT WINAPI TransactionDispenser_BeginTransaction(ITransactionDispenser *iface,
 456         IUnknown *punkOuter,
 457         ISOLEVEL isoLevel,
 458         ULONG isoFlags,
 459         ITransactionOptions *pOptions,
 460         ITransaction **ppTransaction)
 461 {
 462     FIXME("(%p, %p, %08lx, %08lx, %p, %p): semi-stub\n", iface, punkOuter,
 463         isoLevel, isoFlags, pOptions, ppTransaction);
 464
 465     if (!ppTransaction) return E_INVALIDARG;
 466     if (punkOuter) return CLASS_E_NOAGGREGATION;
 467     return Transaction_Create(isoLevel, isoFlags, pOptions, ppTransaction);
 468 }
 469 static const ITransactionDispenserVtbl TransactionDispenser_Vtbl = {
 470     TransactionDispenser_QueryInterface,
 471     TransactionDispenser_AddRef,
 472     TransactionDispenser_Release,
 473     TransactionDispenser_GetOptionsObject,
 474     TransactionDispenser_BeginTransaction
 475 };
 476
 477 static inline TransactionManager *impl_from_IResourceManagerFactory2(IResourceManagerFactory2 *iface)
 478 {
 479     return CONTAINING_RECORD(iface, TransactionManager, IResourceManagerFactory2_iface);
 480 }
 481
 482 static HRESULT WINAPI ResourceManagerFactory2_QueryInterface(IResourceManagerFactory2 *iface, REFIID iid,
 483     void **ppv)
 484 {
 485     TransactionManager *This = impl_from_IResourceManagerFactory2(iface);
 486     return TransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface, iid, ppv);
 487 }
 488
 489 static ULONG WINAPI ResourceManagerFactory2_AddRef(IResourceManagerFactory2 *iface)
 490 {
 491     TransactionManager *This = impl_from_IResourceManagerFactory2(iface);
 492     return TransactionDispenser_AddRef(&This->ITransactionDispenser_iface);
 493 }
 494
 495 static ULONG WINAPI ResourceManagerFactory2_Release(IResourceManagerFactory2 *iface)
 496 {
 497     TransactionManager *This = impl_from_IResourceManagerFactory2(iface);
 498     return TransactionDispenser_Release(&This->ITransactionDispenser_iface);
 499 }
 500 static HRESULT WINAPI ResourceManagerFactory2_Create(IResourceManagerFactory2 *iface,
 501         GUID *pguidRM, CHAR *pszRMName, IResourceManagerSink *pIResMgrSink, IResourceManager **ppResMgr)
 502 {
 503     FIXME("(%p, %s, %s, %p, %p): semi-stub\n", iface, debugstr_guid(pguidRM),
 504         debugstr_a(pszRMName), pIResMgrSink, ppResMgr);
 505     return ResourceManager_Create(&IID_IResourceManager, (void**)ppResMgr);
 506 }
 507 static HRESULT WINAPI ResourceManagerFactory2_CreateEx(IResourceManagerFactory2 *iface,
 508         GUID *pguidRM, CHAR *pszRMName, IResourceManagerSink *pIResMgrSink, REFIID riidRequested, void **ppResMgr)
 509 {
 510     FIXME("(%p, %s, %s, %p, %s, %p): semi-stub\n", iface, debugstr_guid(pguidRM),
 511         debugstr_a(pszRMName), pIResMgrSink, debugstr_guid(riidRequested), ppResMgr);
 512
 513     return ResourceManager_Create(riidRequested, ppResMgr);
 514 }
 515 static const IResourceManagerFactory2Vtbl ResourceManagerFactory2_Vtbl = {
 516     ResourceManagerFactory2_QueryInterface,
 517     ResourceManagerFactory2_AddRef,
 518     ResourceManagerFactory2_Release,
 519     ResourceManagerFactory2_Create,
 520     ResourceManagerFactory2_CreateEx
 521 };
 522
 523 static inline TransactionManager *impl_from_ITransactionImportWhereabouts(ITransactionImportWhereabouts *iface)
 524 {
 525     return CONTAINING_RECORD(iface, TransactionManager, ITransactionImportWhereabouts_iface);
 526 }
 527
 528 static HRESULT WINAPI TransactionImportWhereabouts_QueryInterface(ITransactionImportWhereabouts *iface, REFIID iid,
 529     void **ppv)
 530 {
 531     TransactionManager *This = impl_from_ITransactionImportWhereabouts(iface);
 532     return TransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface, iid, ppv);
 533 }
 534
 535 static ULONG WINAPI TransactionImportWhereabouts_AddRef(ITransactionImportWhereabouts *iface)
 536 {
 537     TransactionManager *This = impl_from_ITransactionImportWhereabouts(iface);
 538     return TransactionDispenser_AddRef(&This->ITransactionDispenser_iface);
 539 }
 540
 541 static ULONG WINAPI TransactionImportWhereabouts_Release(ITransactionImportWhereabouts *iface)
 542 {
 543     TransactionManager *This = impl_from_ITransactionImportWhereabouts(iface);
 544     return TransactionDispenser_Release(&This->ITransactionDispenser_iface);
 545 }
 546 static HRESULT WINAPI TransactionImportWhereabouts_GetWhereaboutsSize(ITransactionImportWhereabouts *iface,
 547         ULONG *pcbWhereabouts)
 548 {
 549     FIXME("(%p, %p): stub returning fake value\n", iface, pcbWhereabouts);
 550
 551     if (!pcbWhereabouts) return E_INVALIDARG;
 552     *pcbWhereabouts = 1;
 553     return S_OK;
 554 }
 555 static HRESULT WINAPI TransactionImportWhereabouts_GetWhereabouts(ITransactionImportWhereabouts *iface,
 556         ULONG cbWhereabouts, BYTE *rgbWhereabouts,ULONG *pcbUsed)
 557 {
 558     FIXME("(%p, %lu, %p, %p): stub returning fake value\n", iface, cbWhereabouts, rgbWhereabouts, pcbUsed);
 559
 560     if (!rgbWhereabouts || !pcbUsed) return E_INVALIDARG;
 561     *rgbWhereabouts = 0;
 562     *pcbUsed = 1;
 563     return S_OK;
 564 }
 565 static const ITransactionImportWhereaboutsVtbl TransactionImportWhereabouts_Vtbl = {
 566     TransactionImportWhereabouts_QueryInterface,
 567     TransactionImportWhereabouts_AddRef,
 568     TransactionImportWhereabouts_Release,
 569     TransactionImportWhereabouts_GetWhereaboutsSize,
 570     TransactionImportWhereabouts_GetWhereabouts
 571 };
 572
 573 static inline TransactionManager *impl_from_ITransactionImport(ITransactionImport *iface)
 574 {
 575     return CONTAINING_RECORD(iface, TransactionManager, ITransactionImport_iface);
 576 }
 577
 578 static HRESULT WINAPI TransactionImport_QueryInterface(ITransactionImport *iface, REFIID iid,
 579     void **ppv)
 580 {
 581     TransactionManager *This = impl_from_ITransactionImport(iface);
 582     return TransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface, iid, ppv);
 583 }
 584
 585 static ULONG WINAPI TransactionImport_AddRef(ITransactionImport *iface)
 586 {
 587     TransactionManager *This = impl_from_ITransactionImport(iface);
 588     return TransactionDispenser_AddRef(&This->ITransactionDispenser_iface);
 589 }
 590
 591 static ULONG WINAPI TransactionImport_Release(ITransactionImport *iface)
 592 {
 593     TransactionManager *This = impl_from_ITransactionImport(iface);
 594     return TransactionDispenser_Release(&This->ITransactionDispenser_iface);
 595 }
 596 static HRESULT WINAPI TransactionImport_Import(ITransactionImport *iface,
 597     ULONG cbTransactionCookie, byte *rgbTransactionCookie, IID *piid, void **ppvTransaction)
 598 {
 599     FIXME("(%p, %lu, %p, %s, %p): stub\n", iface, cbTransactionCookie, rgbTransactionCookie, debugstr_guid(piid), ppvTransaction);
 600
 601     if (!rgbTransactionCookie || !piid || !ppvTransaction) return E_INVALIDARG;
 602     return E_NOTIMPL;
 603 }
 604 static const ITransactionImportVtbl TransactionImport_Vtbl = {
 605     TransactionImport_QueryInterface,
 606     TransactionImport_AddRef,
 607     TransactionImport_Release,
 608     TransactionImport_Import
 609 };
 610
 611 static HRESULT TransactionManager_Create(REFIID riid, void **ppv)
 612 {
 613     TransactionManager *This;
 614     HRESULT ret;
 615
 616     This = malloc(sizeof(*This));
 617     if (!This) return E_OUTOFMEMORY;
 618
 619     This->ITransactionDispenser_iface.lpVtbl = &TransactionDispenser_Vtbl;
 620     This->IResourceManagerFactory2_iface.lpVtbl = &ResourceManagerFactory2_Vtbl;
 621     This->ITransactionImportWhereabouts_iface.lpVtbl = &TransactionImportWhereabouts_Vtbl;
 622     This->ITransactionImport_iface.lpVtbl = &TransactionImport_Vtbl;
 623     This->ref = 1;
 624
 625     ret = ITransactionDispenser_QueryInterface(&This->ITransactionDispenser_iface, riid, ppv);
 626     ITransactionDispenser_Release(&This->ITransactionDispenser_iface);
 627
 628     return ret;
 629 }
 630 /* DTC Proxy Core Object end */
 631
 632 static BOOL is_local_machineA( const CHAR *server )
 633 {
 634     static const CHAR dot[] = ".";
 635     CHAR buffer[MAX_COMPUTERNAME_LENGTH + 1];
 636     DWORD len = ARRAY_SIZE( buffer );
 637
 638     if (!server || !strcmp( server, dot )) return TRUE;
 639     if (GetComputerNameA( buffer, &len ) && !lstrcmpiA( server, buffer )) return TRUE;
 640     return FALSE;
 641 }
 642 static BOOL is_local_machineW( const WCHAR *server )
 643 {
 644     WCHAR buffer[MAX_COMPUTERNAME_LENGTH + 1];
 645     DWORD len = ARRAY_SIZE( buffer );
 646
 647     if (!server || !wcscmp( server, L"." )) return TRUE;
 648     if (GetComputerNameW( buffer, &len ) && !wcsicmp( server, buffer )) return TRUE;
 649     return FALSE;
 650 }
 651
 652 HRESULT CDECL DtcGetTransactionManager(char *host, char *tm_name, REFIID riid,
 653         DWORD dwReserved1, WORD wcbReserved2, void *pvReserved2, void **ppv)
 654 {
 655     TRACE("(%s, %s, %s, %ld, %d, %p, %p)\n", debugstr_a(host), debugstr_a(tm_name),
 656           debugstr_guid(riid), dwReserved1, wcbReserved2, pvReserved2, ppv);
 657
 658     if (!is_local_machineA(host))
 659     {
 660         FIXME("remote computer not supported\n");
 661         return E_NOTIMPL;
 662     }
 663     return TransactionManager_Create(riid, ppv);
 664 }
 665
 666 HRESULT CDECL DtcGetTransactionManagerExA(CHAR *host, CHAR *tm_name, REFIID riid,
 667         DWORD options, void *config, void **ppv)
 668 {
 669     TRACE("(%s, %s, %s, %ld, %p, %p)\n", debugstr_a(host), debugstr_a(tm_name),
 670           debugstr_guid(riid), options, config, ppv);
 671
 672     if (!is_local_machineA(host))
 673     {
 674         FIXME("remote computer not supported\n");
 675         return E_NOTIMPL;
 676     }
 677     return TransactionManager_Create(riid, ppv);
 678 }
 679
 680 HRESULT CDECL DtcGetTransactionManagerExW(WCHAR *host, WCHAR *tm_name, REFIID riid,
 681         DWORD options, void *config, void **ppv)
 682 {
 683     TRACE("(%s, %s, %s, %ld, %p, %p)\n", debugstr_w(host), debugstr_w(tm_name),
 684             debugstr_guid(riid), options, config, ppv);
 685
 686     if (!is_local_machineW(host))
 687     {
 688         FIXME("remote computer not supported\n");
 689         return E_NOTIMPL;
 690     }
 691     return TransactionManager_Create(riid, ppv);
 692 }