ole32: Convert the OpenDll list to a standard Wine list.
[wine] / dlls / ole32 / classmoniker.c
1 /*
2  *                            Class Monikers
3  *
4  *           Copyright 1999  Noomen Hamza
5  *           Copyright 2005-2007  Robert Shearman
6  *
7  * This library is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * This library is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with this library; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20  */
21
22 #include <assert.h>
23 #include <stdarg.h>
24 #include <string.h>
25
26 #define COBJMACROS
27 #define NONAMELESSUNION
28 #define NONAMELESSSTRUCT
29
30 #include "winerror.h"
31 #include "windef.h"
32 #include "winbase.h"
33 #include "winuser.h"
34 #include "winnls.h"
35 #include "wine/debug.h"
36 #include "ole2.h"
37 #include "wine/unicode.h"
38 #include "moniker.h"
39
40 WINE_DEFAULT_DEBUG_CHANNEL(ole);
41
42 #define CHARS_IN_GUID 39
43
44 /* ClassMoniker data structure */
45 typedef struct ClassMoniker
46 {
47     const IMonikerVtbl*  lpVtbl;  /* VTable relative to the IMoniker interface.*/
48     const IROTDataVtbl*  lpVtblRotData;  /* VTable relative to the IROTData interface.*/
49     LONG ref; /* reference counter for this object */
50     CLSID clsid; /* clsid identified by this moniker */
51     IUnknown *pMarshal; /* custom marshaler */
52 } ClassMoniker;
53
54 static inline IMoniker *impl_from_IROTData( IROTData *iface )
55 {
56     return (IMoniker *)((char*)iface - FIELD_OFFSET(ClassMoniker, lpVtblRotData));
57 }
58
59 /*******************************************************************************
60  *        ClassMoniker_QueryInterface
61  *******************************************************************************/
62 static HRESULT WINAPI ClassMoniker_QueryInterface(IMoniker* iface,REFIID riid,void** ppvObject)
63 {
64     ClassMoniker *This = (ClassMoniker *)iface;
65
66     TRACE("(%p,%p,%p)\n",This,riid,ppvObject);
67
68     /* Perform a sanity check on the parameters.*/
69     if (!ppvObject)
70         return E_POINTER;
71
72     /* Initialize the return parameter */
73     *ppvObject = 0;
74
75     /* Compare the riid with the interface IDs implemented by this object.*/
76     if (IsEqualIID(&IID_IUnknown, riid) ||
77         IsEqualIID(&IID_IPersist, riid) ||
78         IsEqualIID(&IID_IPersistStream, riid) ||
79         IsEqualIID(&IID_IMoniker, riid))
80     {
81         *ppvObject = iface;
82     }
83     else if (IsEqualIID(&IID_IROTData, riid))
84         *ppvObject = (IROTData*)&(This->lpVtblRotData);
85     else if (IsEqualIID(&IID_IMarshal, riid))
86     {
87         HRESULT hr = S_OK;
88         if (!This->pMarshal)
89             hr = MonikerMarshal_Create(iface, &This->pMarshal);
90         if (hr != S_OK)
91             return hr;
92         return IUnknown_QueryInterface(This->pMarshal, riid, ppvObject);
93     }
94
95     /* Check that we obtained an interface.*/
96     if (!*ppvObject)
97         return E_NOINTERFACE;
98
99     /* Query Interface always increases the reference count by one when it is successful */
100     IMoniker_AddRef(iface);
101
102     return S_OK;
103 }
104
105 /******************************************************************************
106  *        ClassMoniker_AddRef
107  ******************************************************************************/
108 static ULONG WINAPI ClassMoniker_AddRef(IMoniker* iface)
109 {
110     ClassMoniker *This = (ClassMoniker *)iface;
111
112     TRACE("(%p)\n",This);
113
114     return InterlockedIncrement(&This->ref);
115 }
116
117 /******************************************************************************
118  *        ClassMoniker_Destroy (local function)
119  *******************************************************************************/
120 static HRESULT WINAPI ClassMoniker_Destroy(ClassMoniker* This)
121 {
122     TRACE("(%p)\n",This);
123
124     if (This->pMarshal) IUnknown_Release(This->pMarshal);
125
126     HeapFree(GetProcessHeap(),0,This);
127
128     return S_OK;
129 }
130
131 /******************************************************************************
132  *        ClassMoniker_Release
133  ******************************************************************************/
134 static ULONG WINAPI ClassMoniker_Release(IMoniker* iface)
135 {
136     ClassMoniker *This = (ClassMoniker *)iface;
137     ULONG ref;
138
139     TRACE("(%p)\n",This);
140
141     ref = InterlockedDecrement(&This->ref);
142
143     /* destroy the object if there's no more reference on it */
144     if (ref == 0) ClassMoniker_Destroy(This);
145
146     return ref;
147 }
148
149 /******************************************************************************
150  *        ClassMoniker_GetClassID
151  ******************************************************************************/
152 static HRESULT WINAPI ClassMoniker_GetClassID(IMoniker* iface,CLSID *pClassID)
153 {
154     TRACE("(%p,%p),stub!\n",iface,pClassID);
155
156     if (pClassID==NULL)
157         return E_POINTER;
158
159     *pClassID = CLSID_ClassMoniker;
160
161     return S_OK;
162 }
163
164 /******************************************************************************
165  *        ClassMoniker_IsDirty
166  ******************************************************************************/
167 static HRESULT WINAPI ClassMoniker_IsDirty(IMoniker* iface)
168 {
169     /* Note that the OLE-provided implementations of the IPersistStream::IsDirty
170        method in the OLE-provided moniker interfaces always return S_FALSE because
171        their internal state never changes. */
172
173     TRACE("(%p)\n",iface);
174
175     return S_FALSE;
176 }
177
178 /******************************************************************************
179  *        ClassMoniker_Load
180  ******************************************************************************/
181 static HRESULT WINAPI ClassMoniker_Load(IMoniker* iface,IStream* pStm)
182 {
183     ClassMoniker *This = (ClassMoniker *)iface;
184     HRESULT hr;
185     DWORD zero;
186
187     TRACE("(%p)\n", pStm);
188
189     hr = IStream_Read(pStm, &This->clsid, sizeof(This->clsid), NULL);
190     if (hr != S_OK) return STG_E_READFAULT;
191
192     hr = IStream_Read(pStm, &zero, sizeof(zero), NULL);
193     if ((hr != S_OK) || (zero != 0)) return STG_E_READFAULT;
194
195     return S_OK;
196 }
197
198 /******************************************************************************
199  *        ClassMoniker_Save
200  ******************************************************************************/
201 static HRESULT WINAPI ClassMoniker_Save(IMoniker* iface,
202                                  IStream* pStm,/* pointer to the stream where the object is to be saved */
203                                  BOOL fClearDirty)/* Specifies whether to clear the dirty flag */
204 {
205     ClassMoniker *This = (ClassMoniker *)iface;
206     HRESULT hr;
207     DWORD zero = 0;
208
209     TRACE("(%p, %s)\n", pStm, fClearDirty ? "TRUE" : "FALSE");
210
211     hr = IStream_Write(pStm, &This->clsid, sizeof(This->clsid), NULL);
212     if (FAILED(hr)) return hr;
213
214     hr = IStream_Write(pStm, &zero, sizeof(zero), NULL);
215
216     return hr;
217 }
218
219 /******************************************************************************
220  *        ClassMoniker_GetSizeMax
221  ******************************************************************************/
222 static HRESULT WINAPI ClassMoniker_GetSizeMax(IMoniker* iface,
223                                           ULARGE_INTEGER* pcbSize)/* Pointer to size of stream needed to save object */
224 {
225     TRACE("(%p)\n", pcbSize);
226
227     pcbSize->QuadPart = sizeof(CLSID) + sizeof(DWORD);
228
229     return S_OK;
230 }
231
232 /******************************************************************************
233  *                  ClassMoniker_BindToObject
234  ******************************************************************************/
235 static HRESULT WINAPI ClassMoniker_BindToObject(IMoniker* iface,
236                                             IBindCtx* pbc,
237                                             IMoniker* pmkToLeft,
238                                             REFIID riid,
239                                             VOID** ppvResult)
240 {
241     ClassMoniker *This = (ClassMoniker *)iface;
242     BIND_OPTS2 bindopts;
243     IClassActivator *pActivator;
244     HRESULT hr;
245
246     TRACE("(%p,%p,%p,%p)\n", pbc, pmkToLeft, riid, ppvResult);
247
248     bindopts.cbStruct = sizeof(bindopts);
249     IBindCtx_GetBindOptions(pbc, (BIND_OPTS *)&bindopts);
250
251     if (!pmkToLeft)
252         return CoGetClassObject(&This->clsid, bindopts.dwClassContext, NULL,
253                                 riid, ppvResult);
254     else
255     {
256         hr = IMoniker_BindToObject(pmkToLeft, pbc, NULL, &IID_IClassActivator,
257                                    (void **)&pActivator);
258         if (FAILED(hr)) return hr;
259
260         hr = IClassActivator_GetClassObject(pActivator, &This->clsid,
261                                             bindopts.dwClassContext,
262                                             bindopts.locale, riid, ppvResult);
263
264         IClassActivator_Release(pActivator);
265
266         return hr;
267     }
268 }
269
270 /******************************************************************************
271  *        ClassMoniker_BindToStorage
272  ******************************************************************************/
273 static HRESULT WINAPI ClassMoniker_BindToStorage(IMoniker* iface,
274                                              IBindCtx* pbc,
275                                              IMoniker* pmkToLeft,
276                                              REFIID riid,
277                                              VOID** ppvResult)
278 {
279     TRACE("(%p,%p,%p,%p)\n",pbc, pmkToLeft, riid, ppvResult);
280     return ClassMoniker_BindToObject(iface, pbc, pmkToLeft, riid, ppvResult);
281 }
282
283 /******************************************************************************
284  *        ClassMoniker_Reduce
285  ******************************************************************************/
286 static HRESULT WINAPI ClassMoniker_Reduce(IMoniker* iface,
287                                       IBindCtx* pbc,
288                                       DWORD dwReduceHowFar,
289                                       IMoniker** ppmkToLeft,
290                                       IMoniker** ppmkReduced)
291 {
292     TRACE("(%p,%p,%d,%p,%p)\n",iface,pbc,dwReduceHowFar,ppmkToLeft,ppmkReduced);
293
294     if (!ppmkReduced)
295         return E_POINTER;
296
297     ClassMoniker_AddRef(iface);
298
299     *ppmkReduced = iface;
300
301     return MK_S_REDUCED_TO_SELF;
302 }
303 /******************************************************************************
304  *        ClassMoniker_ComposeWith
305  ******************************************************************************/
306 static HRESULT WINAPI ClassMoniker_ComposeWith(IMoniker* iface,
307                                            IMoniker* pmkRight,
308                                            BOOL fOnlyIfNotGeneric,
309                                            IMoniker** ppmkComposite)
310 {
311     HRESULT res=S_OK;
312     DWORD mkSys,mkSys2;
313     IEnumMoniker* penumMk=0;
314     IMoniker *pmostLeftMk=0;
315     IMoniker* tempMkComposite=0;
316
317     TRACE("(%p,%d,%p)\n", pmkRight, fOnlyIfNotGeneric, ppmkComposite);
318
319     if ((ppmkComposite==NULL)||(pmkRight==NULL))
320         return E_POINTER;
321
322     *ppmkComposite=0;
323
324     IMoniker_IsSystemMoniker(pmkRight,&mkSys);
325
326     /* If pmkRight is an anti-moniker, the returned moniker is NULL */
327     if(mkSys==MKSYS_ANTIMONIKER)
328         return res;
329
330     else
331         /* if pmkRight is a composite whose leftmost component is an anti-moniker,           */
332         /* the returned moniker is the composite after the leftmost anti-moniker is removed. */
333
334          if(mkSys==MKSYS_GENERICCOMPOSITE){
335
336             res=IMoniker_Enum(pmkRight,TRUE,&penumMk);
337
338             if (FAILED(res))
339                 return res;
340
341             res=IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL);
342
343             IMoniker_IsSystemMoniker(pmostLeftMk,&mkSys2);
344
345             if(mkSys2==MKSYS_ANTIMONIKER){
346
347                 IMoniker_Release(pmostLeftMk);
348
349                 tempMkComposite=iface;
350                 IMoniker_AddRef(iface);
351
352                 while(IEnumMoniker_Next(penumMk,1,&pmostLeftMk,NULL)==S_OK){
353
354                     res=CreateGenericComposite(tempMkComposite,pmostLeftMk,ppmkComposite);
355
356                     IMoniker_Release(tempMkComposite);
357                     IMoniker_Release(pmostLeftMk);
358
359                     tempMkComposite=*ppmkComposite;
360                     IMoniker_AddRef(tempMkComposite);
361                 }
362                 return res;
363             }
364             else
365                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
366          }
367          /* If pmkRight is not an anti-moniker, the method combines the two monikers into a generic
368           composite if fOnlyIfNotGeneric is FALSE; if fOnlyIfNotGeneric is TRUE, the method returns
369           a NULL moniker and a return value of MK_E_NEEDGENERIC */
370           else
371             if (!fOnlyIfNotGeneric)
372                 return CreateGenericComposite(iface,pmkRight,ppmkComposite);
373
374             else
375                 return MK_E_NEEDGENERIC;
376 }
377
378 /******************************************************************************
379  *        ClassMoniker_Enum
380  ******************************************************************************/
381 static HRESULT WINAPI ClassMoniker_Enum(IMoniker* iface,BOOL fForward, IEnumMoniker** ppenumMoniker)
382 {
383     TRACE("(%p,%d,%p)\n",iface,fForward,ppenumMoniker);
384
385     if (ppenumMoniker == NULL)
386         return E_POINTER;
387
388     *ppenumMoniker = NULL;
389
390     return S_OK;
391 }
392
393 /******************************************************************************
394  *        ClassMoniker_IsEqual
395  ******************************************************************************/
396 static HRESULT WINAPI ClassMoniker_IsEqual(IMoniker* iface,IMoniker* pmkOtherMoniker)
397 {
398
399     CLSID clsid;
400     LPOLESTR dispName1,dispName2;
401     IBindCtx* bind;
402     HRESULT res = S_FALSE;
403
404     TRACE("(%p,%p)\n",iface,pmkOtherMoniker);
405
406     if (!pmkOtherMoniker) return S_FALSE;
407
408
409     /* check if both are ClassMoniker */
410     if(FAILED (IMoniker_GetClassID(pmkOtherMoniker,&clsid))) return S_FALSE;
411     if(!IsEqualCLSID(&clsid,&CLSID_ClassMoniker)) return S_FALSE;
412
413     /* check if both displaynames are the same */
414     if(SUCCEEDED ((res = CreateBindCtx(0,&bind)))) {
415         if(SUCCEEDED (IMoniker_GetDisplayName(iface,bind,NULL,&dispName1))) {
416             if(SUCCEEDED (IMoniker_GetDisplayName(pmkOtherMoniker,bind,NULL,&dispName2))) {
417                 if(lstrcmpW(dispName1,dispName2)==0) res = S_OK;
418                 CoTaskMemFree(dispName2);
419             }
420             CoTaskMemFree(dispName1);
421         }
422     }
423     return res;
424 }
425
426 /******************************************************************************
427  *        ClassMoniker_Hash
428  ******************************************************************************/
429 static HRESULT WINAPI ClassMoniker_Hash(IMoniker* iface,DWORD* pdwHash)
430 {
431     ClassMoniker *This = (ClassMoniker *)iface;
432
433     TRACE("(%p)\n", pdwHash);
434
435     *pdwHash = This->clsid.Data1;
436
437     return S_OK;
438 }
439
440 /******************************************************************************
441  *        ClassMoniker_IsRunning
442  ******************************************************************************/
443 static HRESULT WINAPI ClassMoniker_IsRunning(IMoniker* iface,
444                                          IBindCtx* pbc,
445                                          IMoniker* pmkToLeft,
446                                          IMoniker* pmkNewlyRunning)
447 {
448     TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, pmkNewlyRunning);
449
450     /* as in native */
451     return E_NOTIMPL;
452 }
453
454 /******************************************************************************
455  *        ClassMoniker_GetTimeOfLastChange
456  ******************************************************************************/
457 static HRESULT WINAPI ClassMoniker_GetTimeOfLastChange(IMoniker* iface,
458                                                    IBindCtx* pbc,
459                                                    IMoniker* pmkToLeft,
460                                                    FILETIME* pItemTime)
461 {
462     TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, pItemTime);
463
464     return MK_E_UNAVAILABLE;
465 }
466
467 /******************************************************************************
468  *        ClassMoniker_Inverse
469  ******************************************************************************/
470 static HRESULT WINAPI ClassMoniker_Inverse(IMoniker* iface,IMoniker** ppmk)
471 {
472     TRACE("(%p)\n",ppmk);
473
474     if (!ppmk)
475         return E_POINTER;
476
477     return CreateAntiMoniker(ppmk);
478 }
479
480 /******************************************************************************
481  *        ClassMoniker_CommonPrefixWith
482  ******************************************************************************/
483 static HRESULT WINAPI ClassMoniker_CommonPrefixWith(IMoniker* iface,IMoniker* pmkOther,IMoniker** ppmkPrefix)
484 {
485     DWORD mkSys;
486     
487     TRACE("(%p, %p)\n", pmkOther, ppmkPrefix);
488
489     *ppmkPrefix = NULL;
490
491     IMoniker_IsSystemMoniker(pmkOther, &mkSys);
492
493     /* If the other moniker is an class moniker that is equal to this moniker, this method sets *ppmkPrefix */
494     /* to this moniker and returns MK_S_US */
495
496     if (mkSys == MKSYS_CLASSMONIKER)
497     {
498         if (IMoniker_IsEqual(iface, pmkOther) == S_OK)
499         {
500             *ppmkPrefix = iface;
501
502             IMoniker_AddRef(iface);
503
504             return MK_S_US;
505         }
506         else
507             return MK_E_NOPREFIX;
508     }
509     else
510         /* otherwise, the method calls the MonikerCommonPrefixWith function. This function correctly handles */
511         /* the case where the other moniker is a generic composite. */
512         return MonikerCommonPrefixWith(iface, pmkOther, ppmkPrefix);
513 }
514
515 /******************************************************************************
516  *        ClassMoniker_RelativePathTo
517  ******************************************************************************/
518 static HRESULT WINAPI ClassMoniker_RelativePathTo(IMoniker* iface,IMoniker* pmOther, IMoniker** ppmkRelPath)
519 {
520     TRACE("(%p, %p)\n",pmOther,ppmkRelPath);
521
522     if (!ppmkRelPath)
523         return E_POINTER;
524
525     *ppmkRelPath = NULL;
526
527     return MK_E_NOTBINDABLE;
528 }
529
530 /******************************************************************************
531  *        ClassMoniker_GetDisplayName
532  ******************************************************************************/
533 static HRESULT WINAPI ClassMoniker_GetDisplayName(IMoniker* iface,
534                                               IBindCtx* pbc,
535                                               IMoniker* pmkToLeft,
536                                               LPOLESTR *ppszDisplayName)
537 {
538     ClassMoniker *This = (ClassMoniker *)iface;
539     static const WCHAR wszClsidPrefix[] = {'c','l','s','i','d',':',0};
540
541     TRACE("(%p, %p, %p)\n", pbc, pmkToLeft, ppszDisplayName);
542
543     if (!ppszDisplayName)
544         return E_POINTER;
545
546     if (pmkToLeft)
547         return E_INVALIDARG;
548
549     *ppszDisplayName = CoTaskMemAlloc(sizeof(wszClsidPrefix) + (CHARS_IN_GUID-2) * sizeof(WCHAR));
550
551     StringFromGUID2(&This->clsid, *ppszDisplayName+sizeof(wszClsidPrefix)/sizeof(WCHAR)-2, CHARS_IN_GUID);
552
553     /* note: this overwrites the opening curly bracket of the CLSID string generated above */
554     memcpy(*ppszDisplayName, wszClsidPrefix, sizeof(wszClsidPrefix)-sizeof(WCHAR));
555
556     /* note: this overwrites the closing curly bracket of the CLSID string generated above */
557     (*ppszDisplayName)[sizeof(wszClsidPrefix)/sizeof(WCHAR)-2+CHARS_IN_GUID-2] = ':';
558     (*ppszDisplayName)[sizeof(wszClsidPrefix)/sizeof(WCHAR)-2+CHARS_IN_GUID-1] = '\0';
559
560     TRACE("string is %s\n", debugstr_w(*ppszDisplayName));
561     return S_OK;
562 }
563
564 /******************************************************************************
565  *        ClassMoniker_ParseDisplayName
566  ******************************************************************************/
567 static HRESULT WINAPI ClassMoniker_ParseDisplayName(IMoniker* iface,
568                                                 IBindCtx* pbc,
569                                                 IMoniker* pmkToLeft,
570                                                 LPOLESTR pszDisplayName,
571                                                 ULONG* pchEaten,
572                                                 IMoniker** ppmkOut)
573 {
574     FIXME("(%p, %p, %s, %p, %p)\n", pbc, pmkToLeft, debugstr_w(pszDisplayName), pchEaten, ppmkOut);
575     return E_NOTIMPL;
576 }
577
578 /******************************************************************************
579  *        ClassMoniker_IsSystemMoniker
580  ******************************************************************************/
581 static HRESULT WINAPI ClassMoniker_IsSystemMoniker(IMoniker* iface,DWORD* pwdMksys)
582 {
583     TRACE("(%p,%p)\n",iface,pwdMksys);
584
585     if (!pwdMksys)
586         return E_POINTER;
587
588     *pwdMksys = MKSYS_CLASSMONIKER;
589
590     return S_OK;
591 }
592
593 /*******************************************************************************
594  *        ClassMonikerIROTData_QueryInterface
595  *******************************************************************************/
596 static HRESULT WINAPI ClassMonikerROTData_QueryInterface(IROTData *iface,REFIID riid,VOID** ppvObject)
597 {
598
599     IMoniker *This = impl_from_IROTData(iface);
600
601     TRACE("(%p,%p,%p)\n",iface,riid,ppvObject);
602
603     return ClassMoniker_QueryInterface(This, riid, ppvObject);
604 }
605
606 /***********************************************************************
607  *        ClassMonikerIROTData_AddRef
608  */
609 static ULONG WINAPI ClassMonikerROTData_AddRef(IROTData *iface)
610 {
611     IMoniker *This = impl_from_IROTData(iface);
612
613     TRACE("(%p)\n",iface);
614
615     return ClassMoniker_AddRef(This);
616 }
617
618 /***********************************************************************
619  *        ClassMonikerIROTData_Release
620  */
621 static ULONG WINAPI ClassMonikerROTData_Release(IROTData* iface)
622 {
623     IMoniker *This = impl_from_IROTData(iface);
624
625     TRACE("(%p)\n",iface);
626
627     return ClassMoniker_Release(This);
628 }
629
630 /******************************************************************************
631  *        ClassMonikerIROTData_GetComparaisonData
632  ******************************************************************************/
633 static HRESULT WINAPI ClassMonikerROTData_GetComparaisonData(IROTData* iface,
634                                                          BYTE* pbData,
635                                                          ULONG cbMax,
636                                                          ULONG* pcbData)
637 {
638     ClassMoniker *This = (ClassMoniker *)impl_from_IROTData(iface);
639
640     TRACE("(%p, %u, %p)\n", pbData, cbMax, pcbData);
641
642     *pcbData = 2*sizeof(CLSID);
643     if (cbMax < *pcbData)
644         return E_OUTOFMEMORY;
645
646     /* write CLSID of the moniker */
647     memcpy(pbData, &CLSID_ClassMoniker, sizeof(CLSID));
648     /* write CLSID the moniker represents */
649     memcpy(pbData+sizeof(CLSID), &This->clsid, sizeof(CLSID));
650
651     return S_OK;
652 }
653
654 /********************************************************************************/
655 /* Virtual function table for the ClassMoniker class which  include IPersist,*/
656 /* IPersistStream and IMoniker functions.                                       */
657 static const IMonikerVtbl ClassMonikerVtbl =
658 {
659     ClassMoniker_QueryInterface,
660     ClassMoniker_AddRef,
661     ClassMoniker_Release,
662     ClassMoniker_GetClassID,
663     ClassMoniker_IsDirty,
664     ClassMoniker_Load,
665     ClassMoniker_Save,
666     ClassMoniker_GetSizeMax,
667     ClassMoniker_BindToObject,
668     ClassMoniker_BindToStorage,
669     ClassMoniker_Reduce,
670     ClassMoniker_ComposeWith,
671     ClassMoniker_Enum,
672     ClassMoniker_IsEqual,
673     ClassMoniker_Hash,
674     ClassMoniker_IsRunning,
675     ClassMoniker_GetTimeOfLastChange,
676     ClassMoniker_Inverse,
677     ClassMoniker_CommonPrefixWith,
678     ClassMoniker_RelativePathTo,
679     ClassMoniker_GetDisplayName,
680     ClassMoniker_ParseDisplayName,
681     ClassMoniker_IsSystemMoniker
682 };
683
684 /********************************************************************************/
685 /* Virtual function table for the IROTData class.                               */
686 static const IROTDataVtbl ROTDataVtbl =
687 {
688     ClassMonikerROTData_QueryInterface,
689     ClassMonikerROTData_AddRef,
690     ClassMonikerROTData_Release,
691     ClassMonikerROTData_GetComparaisonData
692 };
693
694 /******************************************************************************
695  *         ClassMoniker_Construct (local function)
696  *******************************************************************************/
697 static HRESULT WINAPI ClassMoniker_Construct(ClassMoniker* This, REFCLSID rclsid)
698 {
699     TRACE("(%p,%s)\n",This,debugstr_guid(rclsid));
700
701     /* Initialize the virtual function table. */
702     This->lpVtbl        = &ClassMonikerVtbl;
703     This->lpVtblRotData = &ROTDataVtbl;
704     This->ref           = 0;
705     This->clsid         = *rclsid;
706     This->pMarshal      = NULL;
707
708     return S_OK;
709 }
710
711 /******************************************************************************
712  *        CreateClassMoniker    [OLE32.@]
713  ******************************************************************************/
714 HRESULT WINAPI CreateClassMoniker(REFCLSID rclsid, IMoniker **ppmk)
715 {
716     ClassMoniker* newClassMoniker;
717     HRESULT       hr;
718
719     TRACE("(%s,%p)\n", debugstr_guid(rclsid), ppmk);
720
721     newClassMoniker = HeapAlloc(GetProcessHeap(), 0, sizeof(ClassMoniker));
722
723     if (!newClassMoniker)
724         return STG_E_INSUFFICIENTMEMORY;
725
726     hr = ClassMoniker_Construct(newClassMoniker, rclsid);
727
728     if (FAILED(hr))
729     {
730         HeapFree(GetProcessHeap(), 0, newClassMoniker);
731         return hr;
732     }
733
734     return ClassMoniker_QueryInterface((IMoniker *)newClassMoniker, &IID_IMoniker, (void**)ppmk);
735 }
736
737 HRESULT ClassMoniker_CreateFromDisplayName(LPBC pbc, LPCOLESTR szDisplayName,
738                                            LPDWORD pchEaten, LPMONIKER *ppmk)
739 {
740     HRESULT hr;
741     LPCWSTR s = strchrW(szDisplayName, ':');
742     LPCWSTR end;
743     CLSID clsid;
744     BYTE table[256];
745     int i;
746
747     if (!s)
748         return MK_E_SYNTAX;
749
750     s++;
751
752     for (end = s; *end && (*end != ':'); end++)
753         ;
754
755     TRACE("parsing %s\n", debugstr_wn(s, end - s));
756
757     /* validate the CLSID string */
758     if (s[0] == '{')
759     {
760         if ((end - s != 38) || (s[37] != '}'))
761             return MK_E_SYNTAX;
762         s++;
763     }
764     else
765     {
766         if (end - s != 36)
767             return MK_E_SYNTAX;
768     }
769
770     for (i=0; i<36; i++)
771     {
772         if ((i == 8)||(i == 13)||(i == 18)||(i == 23))
773         {
774             if (s[i] != '-')
775                 return MK_E_SYNTAX;
776             continue;
777         }
778         if (!(((s[i] >= '0') && (s[i] <= '9'))  ||
779               ((s[i] >= 'a') && (s[i] <= 'f'))  ||
780               ((s[i] >= 'A') && (s[i] <= 'F'))))
781             return MK_E_SYNTAX;
782     }
783
784     /* quick lookup table */
785     memset(table, 0, 256);
786
787     for (i = 0; i < 10; i++)
788         table['0' + i] = i;
789     for (i = 0; i < 6; i++)
790     {
791         table['A' + i] = i+10;
792         table['a' + i] = i+10;
793     }
794
795     /* in form XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX */
796
797     clsid.Data1 = (table[s[0]] << 28 | table[s[1]] << 24 | table[s[2]] << 20 | table[s[3]] << 16 |
798                    table[s[4]] << 12 | table[s[5]] << 8  | table[s[6]] << 4  | table[s[7]]);
799     clsid.Data2 = table[s[9]] << 12  | table[s[10]] << 8 | table[s[11]] << 4 | table[s[12]];
800     clsid.Data3 = table[s[14]] << 12 | table[s[15]] << 8 | table[s[16]] << 4 | table[s[17]];
801
802     /* these are just sequential bytes */
803     clsid.Data4[0] = table[s[19]] << 4 | table[s[20]];
804     clsid.Data4[1] = table[s[21]] << 4 | table[s[22]];
805     clsid.Data4[2] = table[s[24]] << 4 | table[s[25]];
806     clsid.Data4[3] = table[s[26]] << 4 | table[s[27]];
807     clsid.Data4[4] = table[s[28]] << 4 | table[s[29]];
808     clsid.Data4[5] = table[s[30]] << 4 | table[s[31]];
809     clsid.Data4[6] = table[s[32]] << 4 | table[s[33]];
810     clsid.Data4[7] = table[s[34]] << 4 | table[s[35]];
811
812     hr = CreateClassMoniker(&clsid, ppmk);
813     if (SUCCEEDED(hr))
814         *pchEaten = (*end == ':' ? end + 1 : end) - szDisplayName;
815     return hr;
816 }
817
818 static HRESULT WINAPI ClassMonikerCF_QueryInterface(LPCLASSFACTORY iface,
819                                                   REFIID riid, LPVOID *ppv)
820 {
821     *ppv = NULL;
822     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IClassFactory))
823     {
824         *ppv = iface;
825         IUnknown_AddRef(iface);
826         return S_OK;
827     }
828     return E_NOINTERFACE;
829 }
830
831 static ULONG WINAPI ClassMonikerCF_AddRef(LPCLASSFACTORY iface)
832 {
833     return 2; /* non-heap based object */
834 }
835
836 static ULONG WINAPI ClassMonikerCF_Release(LPCLASSFACTORY iface)
837 {
838     return 1; /* non-heap based object */
839 }
840
841 static HRESULT WINAPI ClassMonikerCF_CreateInstance(LPCLASSFACTORY iface,
842     LPUNKNOWN pUnk, REFIID riid, LPVOID *ppv)
843 {
844     HRESULT hr;
845     IMoniker *pmk;
846
847     TRACE("(%p, %s, %p)\n", pUnk, debugstr_guid(riid), ppv);
848
849     *ppv = NULL;
850
851     if (pUnk)
852         return CLASS_E_NOAGGREGATION;
853
854     hr = CreateClassMoniker(&CLSID_NULL, &pmk);
855     if (FAILED(hr)) return hr;
856
857     hr = IMoniker_QueryInterface(pmk, riid, ppv);
858     IMoniker_Release(pmk);
859
860     return hr;
861 }
862
863 static HRESULT WINAPI ClassMonikerCF_LockServer(LPCLASSFACTORY iface, BOOL fLock)
864 {
865     FIXME("(%d), stub!\n",fLock);
866     return S_OK;
867 }
868
869 static const IClassFactoryVtbl ClassMonikerCFVtbl =
870 {
871     ClassMonikerCF_QueryInterface,
872     ClassMonikerCF_AddRef,
873     ClassMonikerCF_Release,
874     ClassMonikerCF_CreateInstance,
875     ClassMonikerCF_LockServer
876 };
877 static const IClassFactoryVtbl *ClassMonikerCF = &ClassMonikerCFVtbl;
878
879 HRESULT ClassMonikerCF_Create(REFIID riid, LPVOID *ppv)
880 {
881     return IClassFactory_QueryInterface((IClassFactory *)&ClassMonikerCF, riid, ppv);
882 }