1 /*
2 * AntiMonikers implementation
3 *
4 * Copyright 1999 Noomen Hamza
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 <assert.h>
22 #include <stdarg.h>
23 #include <string.h>
24
25 #define COBJMACROS
26 #define NONAMELESSUNION
27
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winerror.h"
31 #include "objbase.h"
32 #include "wine/debug.h"
33 #include "moniker.h"
34
35 WINE_DEFAULT_DEBUG_CHANNEL(ole);
36
37 /* AntiMoniker data structure */
38 typedef struct AntiMonikerImpl{
39 IMoniker IMoniker_iface;
40 IROTData IROTData_iface;
41 LONG ref;
42 IUnknown *pMarshal; /* custom marshaler */
43 } AntiMonikerImpl;
44
impl_from_IMoniker(IMoniker * iface)45 static inline AntiMonikerImpl *impl_from_IMoniker(IMoniker *iface)
46 {
47 return CONTAINING_RECORD(iface, AntiMonikerImpl, IMoniker_iface);
48 }
49
impl_from_IROTData(IROTData * iface)50 static inline AntiMonikerImpl *impl_from_IROTData(IROTData *iface)
51 {
52 return CONTAINING_RECORD(iface, AntiMonikerImpl, IROTData_iface);
53 }
54
55
56 /*******************************************************************************
57 * AntiMoniker_QueryInterface
58 *******************************************************************************/
59 static HRESULT WINAPI
AntiMonikerImpl_QueryInterface(IMoniker * iface,REFIID riid,void ** ppvObject)60 AntiMonikerImpl_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
61 {
62 AntiMonikerImpl *This = impl_from_IMoniker(iface);
63
64 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppvObject);
65
66 /* Perform a sanity check on the parameters.*/
67 if ( ppvObject==0 )
68 return E_INVALIDARG;
69
70 /* Initialize the return parameter */
71 *ppvObject = 0;
72
73 /* Compare the riid with the interface IDs implemented by this object.*/
74 if (IsEqualIID(&IID_IUnknown, riid) ||
75 IsEqualIID(&IID_IPersist, riid) ||
76 IsEqualIID(&IID_IPersistStream, riid) ||
77 IsEqualIID(&IID_IMoniker, riid))
78 *ppvObject = iface;
79 else if (IsEqualIID(&IID_IROTData, riid))
80 *ppvObject = &This->IROTData_iface;
81 else if (IsEqualIID(&IID_IMarshal, riid))
82 {
83 HRESULT hr = S_OK;
84 if (!This->pMarshal)
85 hr = MonikerMarshal_Create(iface, &This->pMarshal);
86 if (hr != S_OK)
87 return hr;
88 return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
89 }
90
91 /* Check that we obtained an interface.*/
92 if ((*ppvObject)==0)
93 return E_NOINTERFACE;
94
95 /* always increase the reference count by one when it is successful */
96 IMoniker_AddRef(iface);
97
98 return S_OK;
99 }
100
101 /******************************************************************************
102 * AntiMoniker_AddRef
103 ******************************************************************************/
104 static ULONG WINAPI
AntiMonikerImpl_AddRef(IMoniker * iface)105 AntiMonikerImpl_AddRef(IMoniker* iface)
106 {
107 AntiMonikerImpl *This = impl_from_IMoniker(iface);
108
109 TRACE("(%p)\n",This);
110
111 return InterlockedIncrement(&This->ref);
112 }
113
114 /******************************************************************************
115 * AntiMoniker_Release
116 ******************************************************************************/
117 static ULONG WINAPI
AntiMonikerImpl_Release(IMoniker * iface)118 AntiMonikerImpl_Release(IMoniker* iface)
119 {
120 AntiMonikerImpl *This = impl_from_IMoniker(iface);
121 ULONG ref;
122
123 TRACE("(%p)\n",This);
124
125 ref = InterlockedDecrement(&This->ref);
126
127 /* destroy the object if there are no more references to it */
128 if (ref == 0)
129 {
130 if (This->pMarshal) IUnknown_Release(This->pMarshal);
131 HeapFree(GetProcessHeap(),0,This);
132 }
133
134 return ref;
135 }
136
137 /******************************************************************************
138 * AntiMoniker_GetClassID
139 ******************************************************************************/
140 static HRESULT WINAPI
AntiMonikerImpl_GetClassID(IMoniker * iface,CLSID * pClassID)141 AntiMonikerImpl_GetClassID(IMoniker* iface,CLSID *pClassID)
142 {
143 TRACE("(%p,%p)\n",iface,pClassID);
144
145 if (pClassID==NULL)
146 return E_POINTER;
147
148 *pClassID = CLSID_AntiMoniker;
149
150 return S_OK;
151 }
152
153 /******************************************************************************
154 * AntiMoniker_IsDirty
155 ******************************************************************************/
156 static HRESULT WINAPI
AntiMonikerImpl_IsDirty(IMoniker * iface)157 AntiMonikerImpl_IsDirty(IMoniker* iface)
158 {
159 /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
160 method in the OLE-provided moniker interfaces always return S_FALSE because
161 their internal state never changes. */
162
163 TRACE("(%p)\n",iface);
164
165 return S_FALSE;
166 }
167
168 /******************************************************************************
169 * AntiMoniker_Load
170 ******************************************************************************/
171 static HRESULT WINAPI
AntiMonikerImpl_Load(IMoniker * iface,IStream * pStm)172 AntiMonikerImpl_Load(IMoniker* iface,IStream* pStm)
173 {
174 DWORD constant=1,dwbuffer;
175 HRESULT res;
176
177 /* data read by this function is only a DWORD constant (must be 1) ! */
178 res=IStream_Read(pStm,&dwbuffer,sizeof(DWORD),NULL);
179
180 if (SUCCEEDED(res)&& dwbuffer!=constant)
181 return E_FAIL;
182
183 return res;
184 }
185
186 /******************************************************************************
187 * AntiMoniker_Save
188 ******************************************************************************/
189 static HRESULT WINAPI
AntiMonikerImpl_Save(IMoniker * iface,IStream * pStm,BOOL fClearDirty)190 AntiMonikerImpl_Save(IMoniker* iface,IStream* pStm,BOOL fClearDirty)
191 {
192 static const DWORD constant = 1;
193 /* data written by this function is only a DWORD constant set to 1 ! */
194 return IStream_Write(pStm,&constant,sizeof(constant),NULL);
195 }
196
197 /******************************************************************************
198 * AntiMoniker_GetSizeMax
199 *
200 * PARAMS
201 * pcbSize [out] Pointer to size of stream needed to save object
202 ******************************************************************************/
203 static HRESULT WINAPI
AntiMonikerImpl_GetSizeMax(IMoniker * iface,ULARGE_INTEGER * pcbSize)204 AntiMonikerImpl_GetSizeMax(IMoniker* iface, ULARGE_INTEGER* pcbSize)
205 {
206 TRACE("(%p,%p)\n",iface,pcbSize);
207
208 if (!pcbSize)
209 return E_POINTER;
210
211 /* for more details see AntiMonikerImpl_Save comments */
212
213 /*
214 * Normally the sizemax must be sizeof DWORD, but
215 * I tested this function it usually return 16 bytes
216 * more than the number of bytes used by AntiMoniker::Save function
217 */
218 pcbSize->u.LowPart = sizeof(DWORD)+16;
219
220 pcbSize->u.HighPart=0;
221
222 return S_OK;
223 }
224
225 /******************************************************************************
226 * AntiMoniker_BindToObject
227 ******************************************************************************/
228 static HRESULT WINAPI
AntiMonikerImpl_BindToObject(IMoniker * iface,IBindCtx * pbc,IMoniker * pmkToLeft,REFIID riid,VOID ** ppvResult)229 AntiMonikerImpl_BindToObject(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
230 REFIID riid, VOID** ppvResult)
231 {
232 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
233 return E_NOTIMPL;
234 }
235
236 /******************************************************************************
237 * AntiMoniker_BindToStorage
238 ******************************************************************************/
239 static HRESULT WINAPI
AntiMonikerImpl_BindToStorage(IMoniker * iface,IBindCtx * pbc,IMoniker * pmkToLeft,REFIID riid,VOID ** ppvResult)240 AntiMonikerImpl_BindToStorage(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
241 REFIID riid, VOID** ppvResult)
242 {
243 TRACE("(%p,%p,%p,%s,%p)\n",iface,pbc,pmkToLeft,debugstr_guid(riid),ppvResult);
244 return E_NOTIMPL;
245 }
246
247 /******************************************************************************
248 * AntiMoniker_Reduce
249 ******************************************************************************/
250 static HRESULT WINAPI
AntiMonikerImpl_Reduce(IMoniker * iface,IBindCtx * pbc,DWORD dwReduceHowFar,IMoniker ** ppmkToLeft,IMoniker ** ppmkReduced)251 AntiMonikerImpl_Reduce(IMoniker* iface, IBindCtx* pbc, DWORD dwReduceHowFar,
252 IMoniker** ppmkToLeft, IMoniker** ppmkReduced)
253 {
254 TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
255
256 if (ppmkReduced==NULL)
257 return E_POINTER;
258
259 AntiMonikerImpl_AddRef(iface);
260
261 *ppmkReduced=iface;
262
263 return MK_S_REDUCED_TO_SELF;
264 }
265 /******************************************************************************
266 * AntiMoniker_ComposeWith
267 ******************************************************************************/
268 static HRESULT WINAPI
AntiMonikerImpl_ComposeWith(IMoniker * iface,IMoniker * pmkRight,BOOL fOnlyIfNotGeneric,IMoniker ** ppmkComposite)269 AntiMonikerImpl_ComposeWith(IMoniker* iface, IMoniker* pmkRight,
270 BOOL fOnlyIfNotGeneric, IMoniker** ppmkComposite)
271 {
272
273 TRACE("(%p,%p,%d,%p)\n",iface,pmkRight,fOnlyIfNotGeneric,ppmkComposite);
274
275 if ((ppmkComposite==NULL)||(pmkRight==NULL))
276 return E_POINTER;
277
278 *ppmkComposite=0;
279
280 if (fOnlyIfNotGeneric)
281 return MK_E_NEEDGENERIC;
282 else
283 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
284 }
285
286 /******************************************************************************
287 * AntiMoniker_Enum
288 ******************************************************************************/
289 static HRESULT WINAPI
AntiMonikerImpl_Enum(IMoniker * iface,BOOL fForward,IEnumMoniker ** ppenumMoniker)290 AntiMonikerImpl_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
291 {
292 TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
293
294 if (ppenumMoniker == NULL)
295 return E_POINTER;
296
297 *ppenumMoniker = NULL;
298
299 return S_OK;
300 }
301
302 /******************************************************************************
303 * AntiMoniker_IsEqual
304 ******************************************************************************/
305 static HRESULT WINAPI
AntiMonikerImpl_IsEqual(IMoniker * iface,IMoniker * pmkOtherMoniker)306 AntiMonikerImpl_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
307 {
308 DWORD mkSys;
309
310 TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
311
312 if (pmkOtherMoniker==NULL)
313 return S_FALSE;
314
315 IMoniker_IsSystemMoniker(pmkOtherMoniker,&mkSys);
316
317 if (mkSys==MKSYS_ANTIMONIKER)
318 return S_OK;
319 else
320 return S_FALSE;
321 }
322
323 /******************************************************************************
324 * AntiMoniker_Hash
325 ******************************************************************************/
AntiMonikerImpl_Hash(IMoniker * iface,DWORD * pdwHash)326 static HRESULT WINAPI AntiMonikerImpl_Hash(IMoniker* iface,DWORD* pdwHash)
327 {
328 if (pdwHash==NULL)
329 return E_POINTER;
330
331 *pdwHash = 0x80000001;
332
333 return S_OK;
334 }
335
336 /******************************************************************************
337 * AntiMoniker_IsRunning
338 ******************************************************************************/
339 static HRESULT WINAPI
AntiMonikerImpl_IsRunning(IMoniker * iface,IBindCtx * pbc,IMoniker * pmkToLeft,IMoniker * pmkNewlyRunning)340 AntiMonikerImpl_IsRunning(IMoniker* iface, IBindCtx* pbc, IMoniker* pmkToLeft,
341 IMoniker* pmkNewlyRunning)
342 {
343 IRunningObjectTable* rot;
344 HRESULT res;
345
346 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pmkNewlyRunning);
347
348 if (pbc==NULL)
349 return E_INVALIDARG;
350
351 res=IBindCtx_GetRunningObjectTable(pbc,&rot);
352
353 if (FAILED(res))
354 return res;
355
356 res = IRunningObjectTable_IsRunning(rot,iface);
357
358 IRunningObjectTable_Release(rot);
359
360 return res;
361 }
362
363 /******************************************************************************
364 * AntiMoniker_GetTimeOfLastChange
365 ******************************************************************************/
AntiMonikerImpl_GetTimeOfLastChange(IMoniker * iface,IBindCtx * pbc,IMoniker * pmkToLeft,FILETIME * pAntiTime)366 static HRESULT WINAPI AntiMonikerImpl_GetTimeOfLastChange(IMoniker* iface,
367 IBindCtx* pbc,
368 IMoniker* pmkToLeft,
369 FILETIME* pAntiTime)
370 {
371 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pAntiTime);
372 return E_NOTIMPL;
373 }
374
375 /******************************************************************************
376 * AntiMoniker_Inverse
377 ******************************************************************************/
378 static HRESULT WINAPI
AntiMonikerImpl_Inverse(IMoniker * iface,IMoniker ** ppmk)379 AntiMonikerImpl_Inverse(IMoniker* iface,IMoniker** ppmk)
380 {
381 TRACE("(%p,%p)\n",iface,ppmk);
382
383 if (ppmk==NULL)
384 return E_POINTER;
385
386 *ppmk=0;
387
388 return MK_E_NOINVERSE;
389 }
390
391 /******************************************************************************
392 * AntiMoniker_CommonPrefixWith
393 ******************************************************************************/
394 static HRESULT WINAPI
AntiMonikerImpl_CommonPrefixWith(IMoniker * iface,IMoniker * pmkOther,IMoniker ** ppmkPrefix)395 AntiMonikerImpl_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
396 {
397 DWORD mkSys;
398
399 IMoniker_IsSystemMoniker(pmkOther,&mkSys);
400
401 if(mkSys==MKSYS_ANTIMONIKER){
402
403 IMoniker_AddRef(iface);
404
405 *ppmkPrefix=iface;
406
407 IMoniker_AddRef(iface);
408
409 return MK_S_US;
410 }
411 else
412 return MonikerCommonPrefixWith(iface,pmkOther,ppmkPrefix);
413 }
414
415 /******************************************************************************
416 * AntiMoniker_RelativePathTo
417 ******************************************************************************/
418 static HRESULT WINAPI
AntiMonikerImpl_RelativePathTo(IMoniker * iface,IMoniker * pmOther,IMoniker ** ppmkRelPath)419 AntiMonikerImpl_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
420 {
421 TRACE("(%p,%p,%p)\n",iface,pmOther,ppmkRelPath);
422
423 if (ppmkRelPath==NULL)
424 return E_POINTER;
425
426 IMoniker_AddRef(pmOther);
427
428 *ppmkRelPath=pmOther;
429
430 return MK_S_HIM;
431 }
432
433 /******************************************************************************
434 * AntiMoniker_GetDisplayName
435 ******************************************************************************/
436 static HRESULT WINAPI
AntiMonikerImpl_GetDisplayName(IMoniker * iface,IBindCtx * pbc,IMoniker * pmkToLeft,LPOLESTR * ppszDisplayName)437 AntiMonikerImpl_GetDisplayName(IMoniker* iface, IBindCtx* pbc,
438 IMoniker* pmkToLeft, LPOLESTR *ppszDisplayName)
439 {
440 static const WCHAR back[]={'\\','.','.',0};
441
442 TRACE("(%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,ppszDisplayName);
443
444 if (ppszDisplayName==NULL)
445 return E_POINTER;
446
447 if (pmkToLeft!=NULL){
448 FIXME("() pmkToLeft!=NULL not implemented\n");
449 return E_NOTIMPL;
450 }
451
452 *ppszDisplayName=CoTaskMemAlloc(sizeof(back));
453
454 if (*ppszDisplayName==NULL)
455 return E_OUTOFMEMORY;
456
457 lstrcpyW(*ppszDisplayName,back);
458
459 return S_OK;
460 }
461
462 /******************************************************************************
463 * AntiMoniker_ParseDisplayName
464 ******************************************************************************/
465 static HRESULT WINAPI
AntiMonikerImpl_ParseDisplayName(IMoniker * iface,IBindCtx * pbc,IMoniker * pmkToLeft,LPOLESTR pszDisplayName,ULONG * pchEaten,IMoniker ** ppmkOut)466 AntiMonikerImpl_ParseDisplayName(IMoniker* iface, IBindCtx* pbc,
467 IMoniker* pmkToLeft, LPOLESTR pszDisplayName,
468 ULONG* pchEaten, IMoniker** ppmkOut)
469 {
470 TRACE("(%p,%p,%p,%p,%p,%p)\n",iface,pbc,pmkToLeft,pszDisplayName,pchEaten,ppmkOut);
471 return E_NOTIMPL;
472 }
473
474 /******************************************************************************
475 * AntiMoniker_IsSystemMoniker
476 ******************************************************************************/
477 static HRESULT WINAPI
AntiMonikerImpl_IsSystemMoniker(IMoniker * iface,DWORD * pwdMksys)478 AntiMonikerImpl_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
479 {
480 TRACE("(%p,%p)\n",iface,pwdMksys);
481
482 if (!pwdMksys)
483 return E_POINTER;
484
485 (*pwdMksys)=MKSYS_ANTIMONIKER;
486
487 return S_OK;
488 }
489
490 /*******************************************************************************
491 * AntiMonikerIROTData_QueryInterface
492 *******************************************************************************/
493 static HRESULT WINAPI
AntiMonikerROTDataImpl_QueryInterface(IROTData * iface,REFIID riid,VOID ** ppvObject)494 AntiMonikerROTDataImpl_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
495 {
496 AntiMonikerImpl *This = impl_from_IROTData(iface);
497
498 TRACE("(%p,%s,%p)\n",iface,debugstr_guid(riid),ppvObject);
499
500 return AntiMonikerImpl_QueryInterface(&This->IMoniker_iface, riid, ppvObject);
501 }
502
503 /***********************************************************************
504 * AntiMonikerIROTData_AddRef
505 */
AntiMonikerROTDataImpl_AddRef(IROTData * iface)506 static ULONG WINAPI AntiMonikerROTDataImpl_AddRef(IROTData *iface)
507 {
508 AntiMonikerImpl *This = impl_from_IROTData(iface);
509
510 TRACE("(%p)\n",iface);
511
512 return AntiMonikerImpl_AddRef(&This->IMoniker_iface);
513 }
514
515 /***********************************************************************
516 * AntiMonikerIROTData_Release
517 */
AntiMonikerROTDataImpl_Release(IROTData * iface)518 static ULONG WINAPI AntiMonikerROTDataImpl_Release(IROTData* iface)
519 {
520 AntiMonikerImpl *This = impl_from_IROTData(iface);
521
522 TRACE("(%p)\n",iface);
523
524 return AntiMonikerImpl_Release(&This->IMoniker_iface);
525 }
526
527 /******************************************************************************
528 * AntiMonikerIROTData_GetComparisonData
529 ******************************************************************************/
530 static HRESULT WINAPI
AntiMonikerROTDataImpl_GetComparisonData(IROTData * iface,BYTE * pbData,ULONG cbMax,ULONG * pcbData)531 AntiMonikerROTDataImpl_GetComparisonData(IROTData* iface, BYTE* pbData,
532 ULONG cbMax, ULONG* pcbData)
533 {
534 DWORD constant = 1;
535
536 TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
537
538 *pcbData = sizeof(CLSID) + sizeof(DWORD);
539 if (cbMax < *pcbData)
540 return E_OUTOFMEMORY;
541
542 memcpy(pbData, &CLSID_AntiMoniker, sizeof(CLSID));
543 memcpy(pbData+sizeof(CLSID), &constant, sizeof(DWORD));
544
545 return S_OK;
546 }
547
548 /********************************************************************************/
549 /* Virtual function table for the AntiMonikerImpl class which include IPersist,*/
550 /* IPersistStream and IMoniker functions. */
551 static const IMonikerVtbl VT_AntiMonikerImpl =
552 {
553 AntiMonikerImpl_QueryInterface,
554 AntiMonikerImpl_AddRef,
555 AntiMonikerImpl_Release,
556 AntiMonikerImpl_GetClassID,
557 AntiMonikerImpl_IsDirty,
558 AntiMonikerImpl_Load,
559 AntiMonikerImpl_Save,
560 AntiMonikerImpl_GetSizeMax,
561 AntiMonikerImpl_BindToObject,
562 AntiMonikerImpl_BindToStorage,
563 AntiMonikerImpl_Reduce,
564 AntiMonikerImpl_ComposeWith,
565 AntiMonikerImpl_Enum,
566 AntiMonikerImpl_IsEqual,
567 AntiMonikerImpl_Hash,
568 AntiMonikerImpl_IsRunning,
569 AntiMonikerImpl_GetTimeOfLastChange,
570 AntiMonikerImpl_Inverse,
571 AntiMonikerImpl_CommonPrefixWith,
572 AntiMonikerImpl_RelativePathTo,
573 AntiMonikerImpl_GetDisplayName,
574 AntiMonikerImpl_ParseDisplayName,
575 AntiMonikerImpl_IsSystemMoniker
576 };
577
578 /********************************************************************************/
579 /* Virtual function table for the IROTData class. */
580 static const IROTDataVtbl VT_ROTDataImpl =
581 {
582 AntiMonikerROTDataImpl_QueryInterface,
583 AntiMonikerROTDataImpl_AddRef,
584 AntiMonikerROTDataImpl_Release,
585 AntiMonikerROTDataImpl_GetComparisonData
586 };
587
588 /******************************************************************************
589 * AntiMoniker_Construct (local function)
590 *******************************************************************************/
AntiMonikerImpl_Construct(AntiMonikerImpl * This)591 static HRESULT AntiMonikerImpl_Construct(AntiMonikerImpl* This)
592 {
593
594 TRACE("(%p)\n",This);
595
596 /* Initialize the virtual function table. */
597 This->IMoniker_iface.lpVtbl = &VT_AntiMonikerImpl;
598 This->IROTData_iface.lpVtbl = &VT_ROTDataImpl;
599 This->ref = 0;
600 This->pMarshal = NULL;
601
602 return S_OK;
603 }
604
605 /******************************************************************************
606 * CreateAntiMoniker [OLE32.@]
607 ******************************************************************************/
CreateAntiMoniker(IMoniker ** ppmk)608 HRESULT WINAPI CreateAntiMoniker(IMoniker **ppmk)
609 {
610 AntiMonikerImpl* newAntiMoniker;
611 HRESULT hr;
612
613 TRACE("(%p)\n",ppmk);
614
615 newAntiMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(AntiMonikerImpl));
616
617 if (newAntiMoniker == 0)
618 return STG_E_INSUFFICIENTMEMORY;
619
620 hr = AntiMonikerImpl_Construct(newAntiMoniker);
621 if (FAILED(hr))
622 {
623 HeapFree(GetProcessHeap(),0,newAntiMoniker);
624 return hr;
625 }
626
627 return AntiMonikerImpl_QueryInterface(&newAntiMoniker->IMoniker_iface, &IID_IMoniker,
628 (void**)ppmk);
629 }
630
AntiMoniker_CreateInstance(IClassFactory * iface,IUnknown * pUnk,REFIID riid,void ** ppv)631 HRESULT WINAPI AntiMoniker_CreateInstance(IClassFactory *iface,
632 IUnknown *pUnk, REFIID riid, void **ppv)
633 {
634 IMoniker *pMoniker;
635 HRESULT hr;
636
637 TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
638
639 *ppv = NULL;
640
641 if (pUnk)
642 return CLASS_E_NOAGGREGATION;
643
644 hr = CreateAntiMoniker(&pMoniker);
645 if (FAILED(hr))
646 return hr;
647
648 hr = IMoniker_QueryInterface(pMoniker, riid, ppv);
649
650 if (FAILED(hr))
651 IMoniker_Release(pMoniker);
652
653 return hr;
654 }
655