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