dlls/comsvcs/main.c

   1 /*
   2  * COM+ Services
   3  *
   4  * Copyright 2013 Alistair Leslie-Hughes
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "ole2.h"
  28 #include "rpcproxy.h"
  29 #include "comsvcs.h"
  30 #include "wine/heap.h"
  31 #include "wine/debug.h"
  32 #include "initguid.h"
  33 #include "comsvcs_classes.h"
  34
  35 WINE_DEFAULT_DEBUG_CHANNEL(comsvcs);
  36
  37 static HINSTANCE COMSVCS_hInstance;
  38
  39 typedef struct dispensermanager
  40 {
  41     IDispenserManager IDispenserManager_iface;
  42     LONG ref;
  43     HANDLE mta_thread, mta_stop_event;
  44 } dispensermanager;
  45
  46 typedef struct holder
  47 {
  48     IHolder IHolder_iface;
  49     LONG ref;
  50
  51     IDispenserDriver *driver;
  52 } holder;
  53
  54 struct new_moniker
  55 {
  56     IMoniker IMoniker_iface;
  57     IROTData IROTData_iface;
  58     LONG refcount;
  59     CLSID clsid;
  60     WCHAR *progid;
  61 };
  62
  63 static HRESULT new_moniker_parse_displayname(IBindCtx *pbc, LPOLESTR name, ULONG *eaten, IMoniker **ret);
  64
  65 static inline dispensermanager *impl_from_IDispenserManager(IDispenserManager *iface)
  66 {
  67     return CONTAINING_RECORD(iface, dispensermanager, IDispenserManager_iface);
  68 }
  69
  70 static inline holder *impl_from_IHolder(IHolder *iface)
  71 {
  72     return CONTAINING_RECORD(iface, holder, IHolder_iface);
  73 }
  74
  75 static struct new_moniker *impl_from_IMoniker(IMoniker *iface)
  76 {
  77     return CONTAINING_RECORD(iface, struct new_moniker, IMoniker_iface);
  78 }
  79
  80 static struct new_moniker *impl_from_IROTData(IROTData *iface)
  81 {
  82     return CONTAINING_RECORD(iface, struct new_moniker, IROTData_iface);
  83 }
  84
  85 static HRESULT WINAPI holder_QueryInterface(IHolder *iface, REFIID riid, void **object)
  86 {
  87     holder *This = impl_from_IHolder(iface);
  88
  89     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), object);
  90
  91     *object = NULL;
  92
  93     if (IsEqualGUID(riid, &IID_IUnknown) ||
  94         IsEqualGUID(riid, &IID_IHolder))
  95     {
  96         *object = &This->IHolder_iface;
  97         IUnknown_AddRef( (IUnknown*)*object);
  98
  99         return S_OK;
 100     }
 101
 102     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),object);
 103     return E_NOINTERFACE;
 104 }
 105
 106 static ULONG WINAPI holder_AddRef(IHolder *iface)
 107 {
 108     holder *This = impl_from_IHolder(iface);
 109     ULONG ref = InterlockedIncrement(&This->ref);
 110     TRACE("(%p)->(%d)\n", This, ref);
 111     return ref;
 112 }
 113
 114 static ULONG WINAPI holder_Release(IHolder *iface)
 115 {
 116     holder *This = impl_from_IHolder(iface);
 117     ULONG ref = InterlockedDecrement(&This->ref);
 118     TRACE("(%p)->(%d)\n", This, ref);
 119
 120     if (!ref)
 121     {
 122         heap_free(This);
 123     }
 124
 125     return ref;
 126 }
 127
 128 static HRESULT WINAPI holder_AllocResource(IHolder *iface, const RESTYPID typeid, RESID *resid)
 129 {
 130     holder *This = impl_from_IHolder(iface);
 131     HRESULT hr;
 132     TIMEINSECS secs;
 133
 134     TRACE("(%p)->(%08lx, %p) stub\n", This, typeid, resid);
 135
 136     hr = IDispenserDriver_CreateResource(This->driver, typeid, resid, &secs);
 137
 138     TRACE("<- 0x%08x\n", hr);
 139     return hr;
 140 }
 141
 142 static HRESULT WINAPI holder_FreeResource(IHolder *iface, const RESID resid)
 143 {
 144     holder *This = impl_from_IHolder(iface);
 145     HRESULT hr;
 146
 147     TRACE("(%p)->(%08lx) stub\n", This, resid);
 148
 149     hr = IDispenserDriver_DestroyResource(This->driver, resid);
 150
 151     TRACE("<- 0x%08x\n", hr);
 152
 153     return hr;
 154 }
 155
 156 static HRESULT WINAPI holder_TrackResource(IHolder *iface, const RESID resid)
 157 {
 158     holder *This = impl_from_IHolder(iface);
 159
 160     FIXME("(%p)->(%08lx) stub\n", This, resid);
 161
 162     return E_NOTIMPL;
 163 }
 164
 165 static HRESULT WINAPI holder_TrackResourceS(IHolder *iface, const SRESID resid)
 166 {
 167     holder *This = impl_from_IHolder(iface);
 168
 169     FIXME("(%p)->(%s) stub\n", This, debugstr_w(resid));
 170
 171     return E_NOTIMPL;
 172 }
 173
 174 static HRESULT WINAPI holder_UntrackResource(IHolder *iface, const RESID resid, const BOOL value)
 175 {
 176     holder *This = impl_from_IHolder(iface);
 177
 178     FIXME("(%p)->(%08lx, %d) stub\n", This, resid, value);
 179
 180     return E_NOTIMPL;
 181 }
 182
 183 static HRESULT WINAPI holder_UntrackResourceS(IHolder *iface, const SRESID resid, const BOOL value)
 184 {
 185     holder *This = impl_from_IHolder(iface);
 186
 187     FIXME("(%p)->(%s, %d) stub\n", This, debugstr_w(resid), value);
 188
 189     return E_NOTIMPL;
 190 }
 191
 192 static HRESULT WINAPI holder_Close(IHolder *iface)
 193 {
 194     holder *This = impl_from_IHolder(iface);
 195
 196     FIXME("(%p) stub\n", This);
 197
 198     IDispenserDriver_Release(This->driver);
 199
 200     return S_OK;
 201 }
 202
 203 static HRESULT WINAPI holder_RequestDestroyResource(IHolder *iface, const RESID resid)
 204 {
 205     holder *This = impl_from_IHolder(iface);
 206
 207     FIXME("(%p)->(%08lx) stub\n", This, resid);
 208
 209     return E_NOTIMPL;
 210 }
 211
 212 struct IHolderVtbl holder_vtbl =
 213 {
 214     holder_QueryInterface,
 215     holder_AddRef,
 216     holder_Release,
 217     holder_AllocResource,
 218     holder_FreeResource,
 219     holder_TrackResource,
 220     holder_TrackResourceS,
 221     holder_UntrackResource,
 222     holder_UntrackResourceS,
 223     holder_Close,
 224     holder_RequestDestroyResource
 225 };
 226
 227 static HRESULT create_holder(IDispenserDriver *driver, IHolder **object)
 228 {
 229     holder *hold;
 230     HRESULT ret;
 231
 232     TRACE("(%p)\n", object);
 233
 234     hold = heap_alloc(sizeof(*hold));
 235     if (!hold)
 236     {
 237         *object = NULL;
 238         return E_OUTOFMEMORY;
 239     }
 240
 241     hold->IHolder_iface.lpVtbl = &holder_vtbl;
 242     hold->ref = 1;
 243     hold->driver = driver;
 244
 245     ret = holder_QueryInterface(&hold->IHolder_iface, &IID_IHolder, (void**)object);
 246     holder_Release(&hold->IHolder_iface);
 247
 248     return ret;
 249 }
 250
 251 static HRESULT WINAPI dismanager_QueryInterface(IDispenserManager *iface, REFIID riid, void **object)
 252 {
 253     dispensermanager *This = impl_from_IDispenserManager(iface);
 254
 255     TRACE("(%p)->(%s %p)\n", This, debugstr_guid(riid), object);
 256
 257     *object = NULL;
 258
 259     if (IsEqualGUID(riid, &IID_IUnknown) ||
 260         IsEqualGUID(riid, &IID_IDispenserManager))
 261     {
 262         *object = &This->IDispenserManager_iface;
 263         IUnknown_AddRef( (IUnknown*)*object);
 264
 265         return S_OK;
 266     }
 267
 268     WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),object);
 269     return E_NOINTERFACE;
 270 }
 271
 272 static ULONG WINAPI dismanager_AddRef(IDispenserManager *iface)
 273 {
 274     dispensermanager *This = impl_from_IDispenserManager(iface);
 275     ULONG ref = InterlockedIncrement(&This->ref);
 276     TRACE("(%p)->(%d)\n", This, ref);
 277     return ref;
 278 }
 279
 280 static ULONG WINAPI dismanager_Release(IDispenserManager *iface)
 281 {
 282     dispensermanager *This = impl_from_IDispenserManager(iface);
 283     ULONG ref = InterlockedDecrement(&This->ref);
 284     TRACE("(%p)->(%d)\n", This, ref);
 285
 286     if (!ref)
 287     {
 288         if (This->mta_thread)
 289         {
 290             SetEvent(This->mta_stop_event);
 291             WaitForSingleObject(This->mta_thread, INFINITE);
 292             CloseHandle(This->mta_stop_event);
 293             CloseHandle(This->mta_thread);
 294         }
 295         heap_free(This);
 296     }
 297
 298     return ref;
 299 }
 300
 301 static DWORD WINAPI mta_thread_proc(void *arg)
 302 {
 303     CoInitializeEx(NULL, COINIT_MULTITHREADED);
 304     WaitForSingleObject(arg, INFINITE);
 305     CoUninitialize();
 306     return 0;
 307 }
 308
 309 static HRESULT WINAPI dismanager_RegisterDispenser(IDispenserManager *iface, IDispenserDriver *driver,
 310                         LPCOLESTR name, IHolder **dispenser)
 311 {
 312     dispensermanager *This = impl_from_IDispenserManager(iface);
 313     HRESULT hr;
 314
 315     TRACE("(%p)->(%p, %s, %p)\n", This, driver, debugstr_w(name), dispenser);
 316
 317     if(!dispenser)
 318         return E_INVALIDARG;
 319
 320     hr = create_holder(driver, dispenser);
 321
 322     if (!This->mta_thread)
 323     {
 324         This->mta_stop_event = CreateEventA(NULL, TRUE, FALSE, NULL);
 325         This->mta_thread = CreateThread(NULL, 0, mta_thread_proc, This->mta_stop_event, 0, NULL);
 326     }
 327
 328     TRACE("<-- 0x%08x, %p\n", hr, *dispenser);
 329
 330     return hr;
 331 }
 332
 333 static HRESULT WINAPI dismanager_GetContext(IDispenserManager *iface, INSTID *id, TRANSID *transid)
 334 {
 335     dispensermanager *This = impl_from_IDispenserManager(iface);
 336
 337     FIXME("(%p)->(%p, %p) stub\n", This, id, transid);
 338
 339     return E_NOTIMPL;
 340 }
 341
 342 struct IDispenserManagerVtbl dismanager_vtbl =
 343 {
 344     dismanager_QueryInterface,
 345     dismanager_AddRef,
 346     dismanager_Release,
 347     dismanager_RegisterDispenser,
 348     dismanager_GetContext
 349 };
 350
 351 static HRESULT WINAPI dispenser_manager_cf_CreateInstance(IClassFactory *iface, IUnknown* outer, REFIID riid,
 352         void **object)
 353 {
 354     dispensermanager *dismanager;
 355     HRESULT ret;
 356
 357     TRACE("(%p %s %p)\n", outer, debugstr_guid(riid), object);
 358
 359     dismanager = heap_alloc_zero(sizeof(*dismanager));
 360     if (!dismanager)
 361     {
 362         *object = NULL;
 363         return E_OUTOFMEMORY;
 364     }
 365
 366     dismanager->IDispenserManager_iface.lpVtbl = &dismanager_vtbl;
 367     dismanager->ref = 1;
 368
 369     ret = dismanager_QueryInterface(&dismanager->IDispenserManager_iface, riid, object);
 370     dismanager_Release(&dismanager->IDispenserManager_iface);
 371
 372     return ret;
 373 }
 374
 375 BOOL WINAPI DllMain(HINSTANCE hinst, DWORD reason, LPVOID lpv)
 376 {
 377     switch(reason)
 378     {
 379     case DLL_WINE_PREATTACH:
 380         return FALSE;    /* prefer native version */
 381     case DLL_PROCESS_ATTACH:
 382         COMSVCS_hInstance = hinst;
 383         DisableThreadLibraryCalls(hinst);
 384         break;
 385     }
 386     return TRUE;
 387 }
 388
 389 static HRESULT WINAPI comsvcscf_QueryInterface(IClassFactory *iface, REFIID riid, void **ppv )
 390 {
 391     *ppv = NULL;
 392
 393     if(IsEqualGUID(&IID_IUnknown, riid)) {
 394         TRACE("(%p)->(IID_IUnknown %p)\n", iface, ppv);
 395         *ppv = iface;
 396     }else if(IsEqualGUID(&IID_IClassFactory, riid)) {
 397         TRACE("(%p)->(IID_IClassFactory %p)\n", iface, ppv);
 398         *ppv = iface;
 399     }
 400
 401     if(*ppv) {
 402         IUnknown_AddRef((IUnknown*)*ppv);
 403         return S_OK;
 404     }
 405
 406     WARN("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppv);
 407     return E_NOINTERFACE;
 408 }
 409
 410 static ULONG WINAPI comsvcscf_AddRef(IClassFactory *iface )
 411 {
 412     TRACE("(%p)\n", iface);
 413     return 2;
 414 }
 415
 416 static ULONG WINAPI comsvcscf_Release(IClassFactory *iface )
 417 {
 418     TRACE("(%p)\n", iface);
 419     return 1;
 420 }
 421
 422 static HRESULT WINAPI comsvcscf_LockServer(IClassFactory *iface, BOOL fLock)
 423 {
 424     TRACE("(%p)->(%x)\n", iface, fLock);
 425     return S_OK;
 426 }
 427
 428 static const IClassFactoryVtbl comsvcscf_vtbl =
 429 {
 430     comsvcscf_QueryInterface,
 431     comsvcscf_AddRef,
 432     comsvcscf_Release,
 433     dispenser_manager_cf_CreateInstance,
 434     comsvcscf_LockServer
 435 };
 436
 437 static HRESULT WINAPI new_moniker_QueryInterface(IMoniker* iface, REFIID riid, void **obj)
 438 {
 439     struct new_moniker *moniker = impl_from_IMoniker(iface);
 440
 441     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 442
 443     *obj = NULL;
 444
 445     if (IsEqualIID(&IID_IUnknown, riid) ||
 446         IsEqualIID(&IID_IPersist, riid) ||
 447         IsEqualIID(&IID_IPersistStream, riid) ||
 448         IsEqualIID(&IID_IMoniker, riid))
 449     {
 450         *obj = iface;
 451     }
 452     else if (IsEqualIID(&IID_IROTData, riid))
 453     {
 454         *obj = &moniker->IROTData_iface;
 455     }
 456
 457     if (*obj)
 458     {
 459         IUnknown_AddRef((IUnknown *)*obj);
 460         return S_OK;
 461     }
 462
 463     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 464     return E_NOINTERFACE;
 465 }
 466
 467 static ULONG WINAPI new_moniker_AddRef(IMoniker* iface)
 468 {
 469     struct new_moniker *moniker = impl_from_IMoniker(iface);
 470     ULONG refcount = InterlockedIncrement(&moniker->refcount);
 471
 472     TRACE("%p, refcount %u.\n", iface, refcount);
 473
 474     return refcount;
 475 }
 476
 477 static ULONG WINAPI new_moniker_Release(IMoniker* iface)
 478 {
 479     struct new_moniker *moniker = impl_from_IMoniker(iface);
 480     ULONG refcount = InterlockedDecrement(&moniker->refcount);
 481
 482     TRACE("%p, refcount %u.\n", iface, refcount);
 483
 484     if (!refcount)
 485     {
 486         heap_free(moniker->progid);
 487         heap_free(moniker);
 488     }
 489
 490     return refcount;
 491 }
 492
 493 static HRESULT WINAPI new_moniker_GetClassID(IMoniker *iface, CLSID *clsid)
 494 {
 495     TRACE("%p, %p.\n", iface, clsid);
 496
 497     if (!clsid)
 498         return E_POINTER;
 499
 500     *clsid = CLSID_NewMoniker;
 501
 502     return S_OK;
 503 }
 504
 505 static HRESULT WINAPI new_moniker_IsDirty(IMoniker* iface)
 506 {
 507     TRACE("%p.\n", iface);
 508
 509     return S_FALSE;
 510 }
 511
 512 static HRESULT WINAPI new_moniker_Load(IMoniker *iface, IStream *stream)
 513 {
 514     struct new_moniker *moniker = impl_from_IMoniker(iface);
 515     DWORD progid_len = 0, len, pad = ~0u;
 516     WCHAR *progid = NULL;
 517     CLSID clsid;
 518     HRESULT hr;
 519
 520     TRACE("%p, %p.\n", iface, stream);
 521
 522     hr = IStream_Read(stream, &clsid, sizeof(clsid), &len);
 523     if (FAILED(hr))
 524         return hr;
 525
 526     if (SUCCEEDED(hr))
 527         hr = IStream_Read(stream, &progid_len, sizeof(progid_len), &len);
 528
 529     if (SUCCEEDED(hr) && progid_len)
 530     {
 531         if (!(progid = heap_alloc(progid_len)))
 532            return E_OUTOFMEMORY;
 533         hr = IStream_Read(stream, progid, progid_len, &len);
 534     }
 535
 536     /* Skip terminator. */
 537     if (SUCCEEDED(hr))
 538         hr = IStream_Read(stream, &pad, sizeof(pad), &len);
 539
 540     if (SUCCEEDED(hr) && pad == 0)
 541     {
 542         moniker->clsid = clsid;
 543         heap_free(moniker->progid);
 544         moniker->progid = progid;
 545         progid = NULL;
 546     }
 547
 548     heap_free(progid);
 549
 550     return hr;
 551 }
 552
 553 static HRESULT WINAPI new_moniker_Save(IMoniker *iface, IStream *stream, BOOL clear_dirty)
 554 {
 555     struct new_moniker *moniker = impl_from_IMoniker(iface);
 556     ULONG written, pad = 0, progid_len = 0;
 557     HRESULT hr;
 558
 559     TRACE("%p, %p, %d.\n", iface, stream, clear_dirty);
 560
 561     if (moniker->progid)
 562         progid_len = lstrlenW(moniker->progid) * sizeof(WCHAR);
 563
 564     hr = IStream_Write(stream, &moniker->clsid, sizeof(moniker->clsid), &written);
 565     if (SUCCEEDED(hr))
 566         hr = IStream_Write(stream, &progid_len, sizeof(progid_len), &written);
 567     if (SUCCEEDED(hr) && progid_len)
 568         hr = IStream_Write(stream, moniker->progid, progid_len, &written);
 569     if (SUCCEEDED(hr))
 570         hr = IStream_Write(stream, &pad, sizeof(pad), &written);
 571
 572     return hr;
 573 }
 574
 575 static HRESULT WINAPI new_moniker_GetSizeMax(IMoniker *iface, ULARGE_INTEGER *size)
 576 {
 577     struct new_moniker *moniker = impl_from_IMoniker(iface);
 578
 579     TRACE("%p, %p.\n", iface, size);
 580
 581     if (!size)
 582         return E_POINTER;
 583
 584     size->QuadPart = sizeof(CLSID) + 2 * sizeof(DWORD);
 585     if (moniker->progid)
 586         size->QuadPart += lstrlenW(moniker->progid) * sizeof(WCHAR);
 587
 588     return S_OK;
 589 }
 590
 591 static HRESULT WINAPI new_moniker_BindToObject(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 592         REFIID riid, void **ret)
 593 {
 594     struct new_moniker *moniker = impl_from_IMoniker(iface);
 595     IClassActivator *activator;
 596     IClassFactory *factory;
 597     BIND_OPTS2 bindopts;
 598     MULTI_QI qi;
 599     HRESULT hr;
 600
 601     TRACE("%p, %p, %p, %s, %p.\n", iface, pbc, pmkToLeft, debugstr_guid(riid), ret);
 602
 603     bindopts.cbStruct = sizeof(bindopts);
 604     if (FAILED(hr = IBindCtx_GetBindOptions(pbc, (BIND_OPTS *)&bindopts)))
 605         return hr;
 606
 607     if (!pmkToLeft)
 608     {
 609         qi.pIID = riid;
 610         qi.pItf = NULL;
 611         qi.hr = S_OK;
 612         hr = CoCreateInstanceEx(&moniker->clsid, NULL, bindopts.dwClassContext, bindopts.pServerInfo, 1, &qi);
 613         *ret = qi.pItf;
 614     }
 615     else
 616     {
 617         if (SUCCEEDED(hr = IMoniker_BindToObject(pmkToLeft, pbc, NULL, &IID_IClassActivator, (void **)&activator)))
 618         {
 619             hr = IClassActivator_GetClassObject(activator, &moniker->clsid, bindopts.dwClassContext, bindopts.locale, riid, ret);
 620             IClassActivator_Release(activator);
 621         }
 622         else if (SUCCEEDED(hr = IMoniker_BindToObject(pmkToLeft, pbc, NULL, &IID_IClassFactory, (void **)&factory)))
 623         {
 624             hr = IClassFactory_CreateInstance(factory, NULL, riid, ret);
 625             IClassFactory_Release(factory);
 626         }
 627     }
 628
 629     return hr;
 630 }
 631
 632 static HRESULT WINAPI new_moniker_BindToStorage(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft, REFIID riid,
 633         void **ret)
 634 {
 635     FIXME("%p, %p, %p, %s, %p.\n", iface, pbc, pmkToLeft, debugstr_guid(riid), ret);
 636
 637     return E_NOTIMPL;
 638 }
 639
 640 static HRESULT WINAPI new_moniker_Reduce(IMoniker *iface, IBindCtx *pbc, DWORD flags, IMoniker **ppmkToLeft,
 641         IMoniker **ret)
 642 {
 643     TRACE("%p, %p, %d, %p, %p.\n", iface, pbc, flags, ppmkToLeft, ret);
 644
 645     if (!ret)
 646         return E_POINTER;
 647
 648     *ret = iface;
 649     IMoniker_AddRef(iface);
 650
 651     return MK_S_REDUCED_TO_SELF;
 652 }
 653
 654 static HRESULT WINAPI new_moniker_ComposeWith(IMoniker *iface, IMoniker *mkRight, BOOL fOnlyIfNotGeneric,
 655         IMoniker **ret)
 656 {
 657     FIXME("%p, %p, %d, %p.\n", iface, mkRight, fOnlyIfNotGeneric, ret);
 658
 659     return E_NOTIMPL;
 660 }
 661
 662 static HRESULT WINAPI new_moniker_Enum(IMoniker *iface, BOOL forward, IEnumMoniker **enum_moniker)
 663 {
 664     TRACE("%p, %d, %p.\n", iface, forward, enum_moniker);
 665
 666     if (!enum_moniker)
 667         return E_POINTER;
 668
 669     *enum_moniker = NULL;
 670
 671     return S_OK;
 672 }
 673
 674 static HRESULT WINAPI new_moniker_IsEqual(IMoniker *iface, IMoniker *other_moniker)
 675 {
 676     FIXME("%p, %p.\n", iface, other_moniker);
 677
 678     return E_NOTIMPL;
 679 }
 680
 681 static HRESULT WINAPI new_moniker_Hash(IMoniker *iface, DWORD *hash)
 682 {
 683     struct new_moniker *moniker = impl_from_IMoniker(iface);
 684
 685     TRACE("%p, %p.\n", iface, hash);
 686
 687     *hash = moniker->clsid.Data1;
 688
 689     return S_OK;
 690 }
 691
 692 static HRESULT WINAPI new_moniker_IsRunning(IMoniker* iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 693         IMoniker *pmkNewlyRunning)
 694 {
 695     FIXME("%p, %p, %p, %p.\n", iface, pbc, pmkToLeft, pmkNewlyRunning);
 696
 697     return E_NOTIMPL;
 698 }
 699
 700 static HRESULT WINAPI new_moniker_GetTimeOfLastChange(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 701         FILETIME *itemtime)
 702 {
 703     TRACE("%p, %p, %p, %p.\n", iface, pbc, pmkToLeft, itemtime);
 704
 705     return MK_E_UNAVAILABLE;
 706 }
 707
 708 static HRESULT WINAPI new_moniker_Inverse(IMoniker *iface, IMoniker **inverse)
 709 {
 710     TRACE("%p, %p.\n", iface, inverse);
 711
 712     return CreateAntiMoniker(inverse);
 713 }
 714
 715 static HRESULT WINAPI new_moniker_CommonPrefixWith(IMoniker *iface, IMoniker *other, IMoniker **ret)
 716 {
 717     FIXME("%p, %p, %p.\n", iface, other, ret);
 718
 719     return E_NOTIMPL;
 720 }
 721
 722 static HRESULT WINAPI new_moniker_RelativePathTo(IMoniker *iface, IMoniker *other, IMoniker **ret)
 723 {
 724     FIXME("%p, %p, %p.\n", iface, other, ret);
 725
 726     return E_NOTIMPL;
 727 }
 728
 729 static HRESULT WINAPI new_moniker_GetDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 730         LPOLESTR *name)
 731 {
 732     FIXME("%p, %p, %p, %p.\n", iface, pbc, pmkToLeft, name);
 733
 734     return E_NOTIMPL;
 735 }
 736
 737 static HRESULT WINAPI new_moniker_ParseDisplayName(IMoniker *iface, IBindCtx *pbc, IMoniker *pmkToLeft,
 738         LPOLESTR name, ULONG *eaten, IMoniker **ret)
 739 {
 740     TRACE("%p, %p, %p, %s, %p, %p.\n", iface, pbc, pmkToLeft, debugstr_w(name), eaten, ret);
 741
 742     return new_moniker_parse_displayname(pbc, name, eaten, ret);
 743 }
 744
 745 static HRESULT WINAPI new_moniker_IsSystemMoniker(IMoniker *iface, DWORD *moniker_type)
 746 {
 747     TRACE("%p, %p.\n", iface, moniker_type);
 748
 749     *moniker_type = MKSYS_NONE;
 750
 751     return S_FALSE;
 752 }
 753
 754 static const IMonikerVtbl new_moniker_vtbl =
 755 {
 756     new_moniker_QueryInterface,
 757     new_moniker_AddRef,
 758     new_moniker_Release,
 759     new_moniker_GetClassID,
 760     new_moniker_IsDirty,
 761     new_moniker_Load,
 762     new_moniker_Save,
 763     new_moniker_GetSizeMax,
 764     new_moniker_BindToObject,
 765     new_moniker_BindToStorage,
 766     new_moniker_Reduce,
 767     new_moniker_ComposeWith,
 768     new_moniker_Enum,
 769     new_moniker_IsEqual,
 770     new_moniker_Hash,
 771     new_moniker_IsRunning,
 772     new_moniker_GetTimeOfLastChange,
 773     new_moniker_Inverse,
 774     new_moniker_CommonPrefixWith,
 775     new_moniker_RelativePathTo,
 776     new_moniker_GetDisplayName,
 777     new_moniker_ParseDisplayName,
 778     new_moniker_IsSystemMoniker
 779 };
 780
 781 static HRESULT WINAPI new_moniker_rotdata_QueryInterface(IROTData *iface, REFIID riid, void **obj)
 782 {
 783     struct new_moniker *moniker = impl_from_IROTData(iface);
 784     return IMoniker_QueryInterface(&moniker->IMoniker_iface, riid, obj);
 785 }
 786
 787 static ULONG WINAPI new_moniker_rotdata_AddRef(IROTData *iface)
 788 {
 789     struct new_moniker *moniker = impl_from_IROTData(iface);
 790     return IMoniker_AddRef(&moniker->IMoniker_iface);
 791 }
 792
 793 static ULONG WINAPI new_moniker_rotdata_Release(IROTData *iface)
 794 {
 795     struct new_moniker *moniker = impl_from_IROTData(iface);
 796     return IMoniker_Release(&moniker->IMoniker_iface);
 797 }
 798
 799 static HRESULT WINAPI new_moniker_rotdata_GetComparisonData(IROTData *iface, byte *data, ULONG data_len, ULONG *length)
 800 {
 801     FIXME("%p, %p, %u, %p.\n", iface, data, data_len, length);
 802
 803     return E_NOTIMPL;
 804 }
 805
 806 static const IROTDataVtbl new_moniker_rotdata_vtbl =
 807 {
 808     new_moniker_rotdata_QueryInterface,
 809     new_moniker_rotdata_AddRef,
 810     new_moniker_rotdata_Release,
 811     new_moniker_rotdata_GetComparisonData,
 812 };
 813
 814 static const BYTE guid_conv_table[256] =
 815 {
 816     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x00 */
 817     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x10 */
 818     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x20 */
 819     0,   1,   2,   3,   4,   5,   6, 7, 8, 9, 0, 0, 0, 0, 0, 0, /* 0x30 */
 820     0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x40 */
 821     0,   0,   0,   0,   0,   0,   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 0x50 */
 822     0, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf                             /* 0x60 */
 823 };
 824
 825 static BOOL is_valid_hex(WCHAR c)
 826 {
 827     return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
 828         (c >= 'A' && c <= 'F');
 829 }
 830
 831 static HRESULT guid_from_string(const WCHAR *s, GUID *ret)
 832 {
 833     BOOL has_brackets;
 834     GUID guid = { 0 };
 835     int i;
 836
 837     memset(ret, 0, sizeof(*ret));
 838
 839     /* Curly brackets are optional. */
 840     has_brackets = s[0] == '{';
 841
 842     if (has_brackets)
 843         s++;
 844
 845     for (i = 0; i < 8; i++)
 846     {
 847         if (!is_valid_hex(s[i])) return FALSE;
 848         guid.Data1 = (guid.Data1 << 4) | guid_conv_table[s[i]];
 849     }
 850     s += 8;
 851
 852     if (s[0] != '-') return FALSE;
 853     s++;
 854
 855     for (i = 0; i < 4; i++)
 856     {
 857         if (!is_valid_hex(s[0])) return FALSE;
 858         guid.Data2 = (guid.Data2 << 4) | guid_conv_table[s[i]];
 859     }
 860     s += 4;
 861
 862     if (s[0] != '-') return FALSE;
 863     s++;
 864
 865     for (i = 0; i < 4; i++)
 866     {
 867         if (!is_valid_hex(s[i])) return FALSE;
 868         guid.Data3 = (guid.Data3 << 4) | guid_conv_table[s[i]];
 869     }
 870     s += 4;
 871
 872     if (s[0] != '-') return FALSE;
 873     s++;
 874
 875     for (i = 0; i < 17; i += 2)
 876     {
 877         if (i == 4)
 878         {
 879             if (s[i] != '-') return FALSE;
 880             i++;
 881         }
 882         if (!is_valid_hex(s[i]) || !is_valid_hex(s[i+1])) return FALSE;
 883         guid.Data4[i / 2] = guid_conv_table[s[i]] << 4 | guid_conv_table[s[i+1]];
 884     }
 885     s += 17;
 886
 887     if (has_brackets && s[0] != '}')
 888         return FALSE;
 889
 890     *ret = guid;
 891
 892     return TRUE;
 893 }
 894
 895 static HRESULT new_moniker_parse_displayname(IBindCtx *pbc, LPOLESTR name, ULONG *eaten, IMoniker **ret)
 896 {
 897     struct new_moniker *moniker;
 898     WCHAR *progid = NULL, *str;
 899     GUID guid;
 900
 901     *ret = NULL;
 902
 903     if (wcsnicmp(name, L"new:", 4))
 904         return MK_E_SYNTAX;
 905     str = name + 4;
 906
 907     if (!guid_from_string(str, &guid))
 908     {
 909         if (FAILED(CLSIDFromProgID(str, &guid)))
 910             return MK_E_SYNTAX;
 911         progid = str;
 912     }
 913
 914     moniker = heap_alloc_zero(sizeof(*moniker));
 915     if (!moniker)
 916         return E_OUTOFMEMORY;
 917
 918     moniker->IMoniker_iface.lpVtbl = &new_moniker_vtbl;
 919     moniker->IROTData_iface.lpVtbl = &new_moniker_rotdata_vtbl;
 920     moniker->refcount = 1;
 921     moniker->clsid = guid;
 922     if (progid)
 923     {
 924         if (!(moniker->progid = heap_alloc((lstrlenW(progid) + 1) * sizeof(WCHAR))))
 925         {
 926             IMoniker_Release(&moniker->IMoniker_iface);
 927             return E_OUTOFMEMORY;
 928         }
 929         lstrcpyW(moniker->progid, progid);
 930     }
 931
 932     *ret = &moniker->IMoniker_iface;
 933
 934     if (eaten)
 935         *eaten = lstrlenW(name);
 936
 937     return S_OK;
 938 }
 939
 940 static HRESULT WINAPI new_moniker_parse_QueryInterface(IParseDisplayName *iface, REFIID riid, void **obj)
 941 {
 942     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 943
 944     if (IsEqualIID(riid, &IID_IParseDisplayName) ||
 945             IsEqualIID(riid, &IID_IUnknown))
 946     {
 947         *obj = iface;
 948         IParseDisplayName_AddRef(iface);
 949         return S_OK;
 950     }
 951
 952     *obj = NULL;
 953     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
 954     return E_NOINTERFACE;
 955 }
 956
 957 static ULONG WINAPI new_moniker_parse_AddRef(IParseDisplayName *iface)
 958 {
 959     return 2;
 960 }
 961
 962 static ULONG WINAPI new_moniker_parse_Release(IParseDisplayName *iface)
 963 {
 964     return 1;
 965 }
 966
 967 static HRESULT WINAPI new_moniker_parse_ParseDisplayName(IParseDisplayName *iface, IBindCtx *pbc, LPOLESTR name,
 968         ULONG *eaten, IMoniker **ret)
 969 {
 970     TRACE("%p, %p, %s, %p, %p.\n", iface, pbc, debugstr_w(name), eaten, ret);
 971
 972     return new_moniker_parse_displayname(pbc, name, eaten, ret);
 973 }
 974
 975 static const IParseDisplayNameVtbl new_moniker_parse_vtbl =
 976 {
 977     new_moniker_parse_QueryInterface,
 978     new_moniker_parse_AddRef,
 979     new_moniker_parse_Release,
 980     new_moniker_parse_ParseDisplayName,
 981 };
 982
 983 static IParseDisplayName new_moniker_parse = { &new_moniker_parse_vtbl };
 984
 985 static HRESULT WINAPI new_moniker_cf_QueryInterface(IClassFactory *iface, REFIID riid, void **obj)
 986 {
 987     TRACE("%p, %s, %p.\n", iface, debugstr_guid(riid), obj);
 988
 989     *obj = NULL;
 990
 991     if (IsEqualGUID(&IID_IUnknown, riid) ||
 992             IsEqualGUID(&IID_IClassFactory, riid))
 993     {
 994         *obj = iface;
 995     }
 996     else if (IsEqualIID(&IID_IParseDisplayName, riid))
 997     {
 998         *obj = &new_moniker_parse;
 999     }
1000
1001     if (*obj)
1002     {
1003         IUnknown_AddRef((IUnknown *)*obj);
1004         return S_OK;
1005     }
1006
1007     WARN("Unsupported interface %s.\n", debugstr_guid(riid));
1008     return E_NOINTERFACE;
1009 }
1010
1011 static HRESULT WINAPI new_moniker_cf_CreateInstance(IClassFactory *iface, IUnknown* outer, REFIID riid, void **object)
1012 {
1013     TRACE("%p, %p, %s, %p.\n", iface, outer, debugstr_guid(riid), object);
1014
1015     if (outer)
1016         FIXME("Aggregation is not supported.\n");
1017
1018     return IParseDisplayName_QueryInterface(&new_moniker_parse, riid, object);
1019 }
1020
1021 static const IClassFactoryVtbl newmoniker_cf_vtbl =
1022 {
1023     new_moniker_cf_QueryInterface,
1024     comsvcscf_AddRef,
1025     comsvcscf_Release,
1026     new_moniker_cf_CreateInstance,
1027     comsvcscf_LockServer
1028 };
1029
1030 static IClassFactory DispenserManageFactory = { &comsvcscf_vtbl };
1031 static IClassFactory NewMonikerFactory = { &newmoniker_cf_vtbl };
1032
1033 /******************************************************************
1034  * DllGetClassObject
1035  */
1036 HRESULT WINAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, void **ppv)
1037 {
1038     if(IsEqualGUID(&CLSID_DispenserManager, rclsid))
1039     {
1040         TRACE("(CLSID_DispenserManager %s %p)\n", debugstr_guid(riid), ppv);
1041         return IClassFactory_QueryInterface(&DispenserManageFactory, riid, ppv);
1042     }
1043     else if (IsEqualGUID(&CLSID_NewMoniker, rclsid))
1044     {
1045         TRACE("(CLSID_NewMoniker %s %p)\n", debugstr_guid(riid), ppv);
1046         return IClassFactory_QueryInterface(&NewMonikerFactory, riid, ppv);
1047     }
1048
1049     FIXME("%s %s %p\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1050     return CLASS_E_CLASSNOTAVAILABLE;
1051 }
1052
1053 /******************************************************************
1054  * DllCanUnloadNow
1055  */
1056 HRESULT WINAPI DllCanUnloadNow(void)
1057 {
1058     return S_FALSE;
1059 }
1060
1061 /***********************************************************************
1062  *              DllRegisterServer (comsvcs.@)
1063  */
1064 HRESULT WINAPI DllRegisterServer(void)
1065 {
1066     return __wine_register_resources( COMSVCS_hInstance );
1067 }
1068
1069 /***********************************************************************
1070  *              DllUnregisterServer (comsvcs.@)
1071  */
1072 HRESULT WINAPI DllUnregisterServer(void)
1073 {
1074     return __wine_unregister_resources( COMSVCS_hInstance );
1075 }