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