dbghelp: When handling a P augmentation in FDE/DIE parsing, throw away the DW_EH_indi...
[wine] / dlls / ole32 / comcat.c
1 /*
2  * Comcat implementation
3  *
4  * Copyright (C) 2002 John K. Hohm
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 <string.h>
22 #include <stdarg.h>
23
24 #define COBJMACROS
25
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "winreg.h"
30 #include "winerror.h"
31
32 #include "ole2.h"
33 #include "comcat.h"
34 #include "wine/unicode.h"
35 #include "wine/debug.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(ole);
38
39 typedef struct
40 {
41     const ICatRegisterVtbl *lpVtbl;
42     const ICatInformationVtbl *infVtbl;
43 } ComCatMgrImpl;
44
45 struct class_categories {
46     LPCWSTR impl_strings;
47     LPCWSTR req_strings;
48 };
49
50 static LPENUMCATEGORYINFO COMCAT_IEnumCATEGORYINFO_Construct(LCID lcid);
51 static LPENUMGUID COMCAT_CLSID_IEnumGUID_Construct(struct class_categories *class_categories);
52 static LPENUMGUID COMCAT_CATID_IEnumGUID_Construct(REFCLSID rclsid, LPCWSTR impl_req);
53
54 /**********************************************************************
55  * File-scope string constants
56  */
57 static const WCHAR comcat_keyname[] = {
58     'C','o','m','p','o','n','e','n','t',' ','C','a','t','e','g','o','r','i','e','s',0 };
59 static const WCHAR impl_keyname[] = {
60     'I','m','p','l','e','m','e','n','t','e','d',' ','C','a','t','e','g','o','r','i','e','s',0 };
61 static const WCHAR req_keyname[] = {
62     'R','e','q','u','i','r','e','d',' ','C','a','t','e','g','o','r','i','e','s',0 };
63 static const WCHAR clsid_keyname[] = { 'C','L','S','I','D',0 };
64
65
66 static inline ComCatMgrImpl *impl_from_ICatInformation( ICatInformation *iface )
67 {
68     return (ComCatMgrImpl *)((char*)iface - FIELD_OFFSET(ComCatMgrImpl, infVtbl));
69 }
70
71
72 /**********************************************************************
73  * COMCAT_RegisterClassCategories
74  */
75 static HRESULT COMCAT_RegisterClassCategories(
76     REFCLSID rclsid,
77     LPCWSTR type,
78     ULONG cCategories,
79     const CATID *rgcatid)
80 {
81     WCHAR keyname[39];
82     HRESULT res;
83     HKEY clsid_key, class_key, type_key;
84
85     if (cCategories && rgcatid == NULL) return E_POINTER;
86
87     /* Format the class key name. */
88     res = StringFromGUID2(rclsid, keyname, 39);
89     if (FAILED(res)) return res;
90
91     /* Create (or open) the CLSID key. */
92     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, clsid_keyname, 0, NULL, 0,
93                           KEY_READ | KEY_WRITE, NULL, &clsid_key, NULL);
94     if (res != ERROR_SUCCESS) return E_FAIL;
95
96     /* Create (or open) the class key. */
97     res = RegCreateKeyExW(clsid_key, keyname, 0, NULL, 0,
98                           KEY_READ | KEY_WRITE, NULL, &class_key, NULL);
99     if (res == ERROR_SUCCESS) {
100         /* Create (or open) the category type key. */
101         res = RegCreateKeyExW(class_key, type, 0, NULL, 0,
102                               KEY_READ | KEY_WRITE, NULL, &type_key, NULL);
103         if (res == ERROR_SUCCESS) {
104             for (; cCategories; --cCategories, ++rgcatid) {
105                 HKEY key;
106
107                 /* Format the category key name. */
108                 res = StringFromGUID2(rgcatid, keyname, 39);
109                 if (FAILED(res)) continue;
110
111                 /* Do the register. */
112                 res = RegCreateKeyExW(type_key, keyname, 0, NULL, 0,
113                                       KEY_READ | KEY_WRITE, NULL, &key, NULL);
114                 if (res == ERROR_SUCCESS) RegCloseKey(key);
115             }
116             res = S_OK;
117         } else res = E_FAIL;
118         RegCloseKey(class_key);
119     } else res = E_FAIL;
120     RegCloseKey(clsid_key);
121
122     return res;
123 }
124
125 /**********************************************************************
126  * COMCAT_UnRegisterClassCategories
127  */
128 static HRESULT COMCAT_UnRegisterClassCategories(
129     REFCLSID rclsid,
130     LPCWSTR type,
131     ULONG cCategories,
132     const CATID *rgcatid)
133 {
134     WCHAR keyname[68] = { 'C', 'L', 'S', 'I', 'D', '\\' };
135     HRESULT res;
136     HKEY type_key;
137
138     if (cCategories && rgcatid == NULL) return E_POINTER;
139
140     /* Format the class category type key name. */
141     res = StringFromGUID2(rclsid, keyname + 6, 39);
142     if (FAILED(res)) return res;
143     keyname[44] = '\\';
144     lstrcpyW(keyname + 45, type);
145
146     /* Open the class category type key. */
147     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0,
148                         KEY_READ | KEY_WRITE, &type_key);
149     if (res != ERROR_SUCCESS) return E_FAIL;
150
151     for (; cCategories; --cCategories, ++rgcatid) {
152         /* Format the category key name. */
153         res = StringFromGUID2(rgcatid, keyname, 39);
154         if (FAILED(res)) continue;
155
156         /* Do the unregister. */
157         RegDeleteKeyW(type_key, keyname);
158     }
159     RegCloseKey(type_key);
160
161     return S_OK;
162 }
163
164 /**********************************************************************
165  * COMCAT_GetCategoryDesc
166  */
167 static HRESULT COMCAT_GetCategoryDesc(HKEY key, LCID lcid, PWCHAR pszDesc,
168                                       ULONG buf_wchars)
169 {
170     static const WCHAR fmt[] = { '%', 'l', 'X', 0 };
171     WCHAR valname[5];
172     HRESULT res;
173     DWORD type, size = (buf_wchars - 1) * sizeof(WCHAR);
174
175     if (pszDesc == NULL) return E_INVALIDARG;
176
177     /* FIXME: lcid comparisons are more complex than this! */
178     wsprintfW(valname, fmt, lcid);
179     res = RegQueryValueExW(key, valname, 0, &type, (LPBYTE)pszDesc, &size);
180     if (res != ERROR_SUCCESS || type != REG_SZ) {
181         FIXME("Simplified lcid comparison\n");
182         return CAT_E_NODESCRIPTION;
183     }
184     pszDesc[size / sizeof(WCHAR)] = 0;
185
186     return S_OK;
187 }
188
189 /**********************************************************************
190  * COMCAT_PrepareClassCategories
191  */
192 static struct class_categories *COMCAT_PrepareClassCategories(
193     ULONG impl_count, const CATID *impl_catids, ULONG req_count, const CATID *req_catids)
194 {
195     struct class_categories *categories;
196     WCHAR *strings;
197
198     categories = HeapAlloc(
199         GetProcessHeap(), HEAP_ZERO_MEMORY,
200         sizeof(struct class_categories) +
201         ((impl_count + req_count) * 39 + 2) * sizeof(WCHAR));
202     if (categories == NULL) return categories;
203
204     strings = (WCHAR *)(categories + 1);
205     categories->impl_strings = strings;
206     while (impl_count--) {
207         StringFromGUID2(impl_catids++, strings, 39);
208         strings += 39;
209     }
210     *strings++ = 0;
211
212     categories->req_strings = strings;
213     while (req_count--) {
214         StringFromGUID2(req_catids++, strings, 39);
215         strings += 39;
216     }
217     *strings++ = 0;
218
219     return categories;
220 }
221
222 /**********************************************************************
223  * COMCAT_IsClassOfCategories
224  */
225 static HRESULT COMCAT_IsClassOfCategories(
226     HKEY key,
227     struct class_categories const* categories)
228 {
229     HKEY subkey;
230     HRESULT res;
231     DWORD index;
232     LPCWSTR string;
233
234     /* Check that every given category is implemented by class. */
235     res = RegOpenKeyExW(key, impl_keyname, 0, KEY_READ, &subkey);
236     if (res != ERROR_SUCCESS) return S_FALSE;
237     for (string = categories->impl_strings; *string; string += 39) {
238         HKEY catkey;
239         res = RegOpenKeyExW(subkey, string, 0, 0, &catkey);
240         if (res != ERROR_SUCCESS) {
241             RegCloseKey(subkey);
242             return S_FALSE;
243         }
244         RegCloseKey(catkey);
245     }
246     RegCloseKey(subkey);
247
248     /* Check that all categories required by class are given. */
249     res = RegOpenKeyExW(key, req_keyname, 0, KEY_READ, &subkey);
250     if (res == ERROR_SUCCESS) {
251         for (index = 0; ; ++index) {
252             WCHAR keyname[39];
253             DWORD size = 39;
254
255             res = RegEnumKeyExW(subkey, index, keyname, &size,
256                                 NULL, NULL, NULL, NULL);
257             if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
258             if (size != 38) continue; /* bogus catid in registry */
259             for (string = categories->req_strings; *string; string += 39)
260                 if (!strcmpiW(string, keyname)) break;
261             if (!*string) {
262                 RegCloseKey(subkey);
263                 return S_FALSE;
264             }
265         }
266         RegCloseKey(subkey);
267     }
268
269     return S_OK;
270 }
271
272 /**********************************************************************
273  * COMCAT_ICatRegister_QueryInterface
274  */
275 static HRESULT WINAPI COMCAT_ICatRegister_QueryInterface(
276     LPCATREGISTER iface,
277     REFIID riid,
278     LPVOID *ppvObj)
279 {
280     ComCatMgrImpl *This = (ComCatMgrImpl *)iface;
281     TRACE("%s\n",debugstr_guid(riid));
282
283     if (ppvObj == NULL) return E_POINTER;
284
285     if (IsEqualGUID(riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_ICatRegister)) {
286         *ppvObj = iface;
287         IUnknown_AddRef(iface);
288         return S_OK;
289     }
290
291     if (IsEqualGUID(riid, &IID_ICatInformation)) {
292         *ppvObj = &This->infVtbl;
293         IUnknown_AddRef(iface);
294         return S_OK;
295     }
296
297     return E_NOINTERFACE;
298 }
299
300 /**********************************************************************
301  * COMCAT_ICatRegister_AddRef
302  */
303 static ULONG WINAPI COMCAT_ICatRegister_AddRef(LPCATREGISTER iface)
304 {
305     return 2; /* non-heap based object */
306 }
307
308 /**********************************************************************
309  * COMCAT_ICatRegister_Release
310  */
311 static ULONG WINAPI COMCAT_ICatRegister_Release(LPCATREGISTER iface)
312 {
313     return 1; /* non-heap based object */
314 }
315
316 /**********************************************************************
317  * COMCAT_ICatRegister_RegisterCategories
318  */
319 static HRESULT WINAPI COMCAT_ICatRegister_RegisterCategories(
320     LPCATREGISTER iface,
321     ULONG cCategories,
322     CATEGORYINFO *rgci)
323 {
324     HKEY comcat_key;
325     HRESULT res;
326
327     TRACE("\n");
328
329     if (cCategories && rgci == NULL)
330         return E_POINTER;
331
332     /* Create (or open) the component categories key. */
333     res = RegCreateKeyExW(HKEY_CLASSES_ROOT, comcat_keyname, 0, NULL, 0,
334                           KEY_READ | KEY_WRITE, NULL, &comcat_key, NULL);
335     if (res != ERROR_SUCCESS) return E_FAIL;
336
337     for (; cCategories; --cCategories, ++rgci) {
338         static const WCHAR fmt[] = { '%', 'l', 'X', 0 };
339         WCHAR keyname[39];
340         WCHAR valname[9];
341         HKEY cat_key;
342
343         /* Create (or open) the key for this category. */
344         if (!StringFromGUID2(&rgci->catid, keyname, 39)) continue;
345         res = RegCreateKeyExW(comcat_key, keyname, 0, NULL, 0,
346                               KEY_READ | KEY_WRITE, NULL, &cat_key, NULL);
347         if (res != ERROR_SUCCESS) continue;
348
349         /* Set the value for this locale's description. */
350         wsprintfW(valname, fmt, rgci->lcid);
351         RegSetValueExW(cat_key, valname, 0, REG_SZ,
352                        (CONST BYTE*)(rgci->szDescription),
353                        (lstrlenW(rgci->szDescription) + 1) * sizeof(WCHAR));
354
355         RegCloseKey(cat_key);
356     }
357
358     RegCloseKey(comcat_key);
359     return S_OK;
360 }
361
362 /**********************************************************************
363  * COMCAT_ICatRegister_UnRegisterCategories
364  */
365 static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterCategories(
366     LPCATREGISTER iface,
367     ULONG cCategories,
368     CATID *rgcatid)
369 {
370     HKEY comcat_key;
371     HRESULT res;
372
373     TRACE("\n");
374
375     if (cCategories && rgcatid == NULL)
376         return E_POINTER;
377
378     /* Open the component categories key. */
379     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, comcat_keyname, 0,
380                         KEY_READ | KEY_WRITE, &comcat_key);
381     if (res != ERROR_SUCCESS) return E_FAIL;
382
383     for (; cCategories; --cCategories, ++rgcatid) {
384         WCHAR keyname[39];
385
386         /* Delete the key for this category. */
387         if (!StringFromGUID2(rgcatid, keyname, 39)) continue;
388         RegDeleteKeyW(comcat_key, keyname);
389     }
390
391     RegCloseKey(comcat_key);
392     return S_OK;
393 }
394
395 /**********************************************************************
396  * COMCAT_ICatRegister_RegisterClassImplCategories
397  */
398 static HRESULT WINAPI COMCAT_ICatRegister_RegisterClassImplCategories(
399     LPCATREGISTER iface,
400     REFCLSID rclsid,
401     ULONG cCategories,
402     CATID *rgcatid)
403 {
404     TRACE("\n");
405
406     return COMCAT_RegisterClassCategories(
407         rclsid, impl_keyname, cCategories, rgcatid);
408 }
409
410 /**********************************************************************
411  * COMCAT_ICatRegister_UnRegisterClassImplCategories
412  */
413 static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterClassImplCategories(
414     LPCATREGISTER iface,
415     REFCLSID rclsid,
416     ULONG cCategories,
417     CATID *rgcatid)
418 {
419     TRACE("\n");
420
421     return COMCAT_UnRegisterClassCategories(
422         rclsid, impl_keyname, cCategories, rgcatid);
423 }
424
425 /**********************************************************************
426  * COMCAT_ICatRegister_RegisterClassReqCategories
427  */
428 static HRESULT WINAPI COMCAT_ICatRegister_RegisterClassReqCategories(
429     LPCATREGISTER iface,
430     REFCLSID rclsid,
431     ULONG cCategories,
432     CATID *rgcatid)
433 {
434     TRACE("\n");
435
436     return COMCAT_RegisterClassCategories(
437         rclsid, req_keyname, cCategories, rgcatid);
438 }
439
440 /**********************************************************************
441  * COMCAT_ICatRegister_UnRegisterClassReqCategories
442  */
443 static HRESULT WINAPI COMCAT_ICatRegister_UnRegisterClassReqCategories(
444     LPCATREGISTER iface,
445     REFCLSID rclsid,
446     ULONG cCategories,
447     CATID *rgcatid)
448 {
449     TRACE("\n");
450
451     return COMCAT_UnRegisterClassCategories(
452         rclsid, req_keyname, cCategories, rgcatid);
453 }
454
455 /**********************************************************************
456  * COMCAT_ICatInformation_QueryInterface
457  */
458 static HRESULT WINAPI COMCAT_ICatInformation_QueryInterface(
459     LPCATINFORMATION iface,
460     REFIID riid,
461     LPVOID *ppvObj)
462 {
463     ComCatMgrImpl *This = impl_from_ICatInformation( iface );
464     return IUnknown_QueryInterface((LPUNKNOWN)This, riid, ppvObj);
465 }
466
467 /**********************************************************************
468  * COMCAT_ICatInformation_AddRef
469  */
470 static ULONG WINAPI COMCAT_ICatInformation_AddRef(LPCATINFORMATION iface)
471 {
472     ComCatMgrImpl *This = impl_from_ICatInformation( iface );
473     return IUnknown_AddRef((LPUNKNOWN)This);
474 }
475
476 /**********************************************************************
477  * COMCAT_ICatInformation_Release
478  */
479 static ULONG WINAPI COMCAT_ICatInformation_Release(LPCATINFORMATION iface)
480 {
481     ComCatMgrImpl *This = impl_from_ICatInformation( iface );
482     return IUnknown_Release((LPUNKNOWN)This);
483 }
484
485 /**********************************************************************
486  * COMCAT_ICatInformation_EnumCategories
487  */
488 static HRESULT WINAPI COMCAT_ICatInformation_EnumCategories(
489     LPCATINFORMATION iface,
490     LCID lcid,
491     LPENUMCATEGORYINFO *ppenumCatInfo)
492 {
493     TRACE("\n");
494
495     if (ppenumCatInfo == NULL) return E_POINTER;
496
497     *ppenumCatInfo = COMCAT_IEnumCATEGORYINFO_Construct(lcid);
498     if (*ppenumCatInfo == NULL) return E_OUTOFMEMORY;
499     IEnumCATEGORYINFO_AddRef(*ppenumCatInfo);
500     return S_OK;
501 }
502
503 /**********************************************************************
504  * COMCAT_ICatInformation_GetCategoryDesc
505  */
506 static HRESULT WINAPI COMCAT_ICatInformation_GetCategoryDesc(
507     LPCATINFORMATION iface,
508     REFCATID rcatid,
509     LCID lcid,
510     PWCHAR *ppszDesc)
511 {
512     WCHAR keyname[60] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
513                           't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
514                           'r', 'i', 'e', 's', '\\', 0 };
515     HKEY key;
516     HRESULT res;
517
518     TRACE("CATID: %s LCID: %x\n",debugstr_guid(rcatid), lcid);
519
520     if (rcatid == NULL || ppszDesc == NULL) return E_INVALIDARG;
521
522     /* Open the key for this category. */
523     if (!StringFromGUID2(rcatid, keyname + 21, 39)) return E_FAIL;
524     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &key);
525     if (res != ERROR_SUCCESS) return CAT_E_CATIDNOEXIST;
526
527     /* Allocate a sensible amount of memory for the description. */
528     *ppszDesc = CoTaskMemAlloc(128 * sizeof(WCHAR));
529     if (*ppszDesc == NULL) {
530         RegCloseKey(key);
531         return E_OUTOFMEMORY;
532     }
533
534     /* Get the description, and make sure it's null terminated. */
535     res = COMCAT_GetCategoryDesc(key, lcid, *ppszDesc, 128);
536     RegCloseKey(key);
537     if (FAILED(res)) {
538         CoTaskMemFree(*ppszDesc);
539         return res;
540     }
541
542     return S_OK;
543 }
544
545 /**********************************************************************
546  * COMCAT_ICatInformation_EnumClassesOfCategories
547  */
548 static HRESULT WINAPI COMCAT_ICatInformation_EnumClassesOfCategories(
549     LPCATINFORMATION iface,
550     ULONG cImplemented,
551     CATID *rgcatidImpl,
552     ULONG cRequired,
553     CATID *rgcatidReq,
554     LPENUMCLSID *ppenumCLSID)
555 {
556     struct class_categories *categories;
557
558     TRACE("\n");
559
560         if (cImplemented == (ULONG)-1)
561                 cImplemented = 0;
562         if (cRequired == (ULONG)-1)
563                 cRequired = 0;
564
565     if (ppenumCLSID == NULL ||
566         (cImplemented && rgcatidImpl == NULL) ||
567         (cRequired && rgcatidReq == NULL)) return E_POINTER;
568
569     categories = COMCAT_PrepareClassCategories(cImplemented, rgcatidImpl,
570                                                cRequired, rgcatidReq);
571     if (categories == NULL) return E_OUTOFMEMORY;
572     *ppenumCLSID = COMCAT_CLSID_IEnumGUID_Construct(categories);
573     if (*ppenumCLSID == NULL) {
574         HeapFree(GetProcessHeap(), 0, categories);
575         return E_OUTOFMEMORY;
576     }
577     IEnumGUID_AddRef(*ppenumCLSID);
578     return S_OK;
579 }
580
581 /**********************************************************************
582  * COMCAT_ICatInformation_IsClassOfCategories
583  */
584 static HRESULT WINAPI COMCAT_ICatInformation_IsClassOfCategories(
585     LPCATINFORMATION iface,
586     REFCLSID rclsid,
587     ULONG cImplemented,
588     CATID *rgcatidImpl,
589     ULONG cRequired,
590     CATID *rgcatidReq)
591 {
592     WCHAR keyname[45] = { 'C', 'L', 'S', 'I', 'D', '\\', 0 };
593     HRESULT res;
594     struct class_categories *categories;
595     HKEY key;
596
597     if (WINE_TRACE_ON(ole)) {
598         ULONG count;
599         TRACE("CLSID: %s Implemented %u\n",debugstr_guid(rclsid),cImplemented);
600         for (count = 0; count < cImplemented; ++count)
601             TRACE("    %s\n",debugstr_guid(&rgcatidImpl[count]));
602         TRACE("Required %u\n",cRequired);
603         for (count = 0; count < cRequired; ++count)
604             TRACE("    %s\n",debugstr_guid(&rgcatidReq[count]));
605     }
606
607     if ((cImplemented && rgcatidImpl == NULL) ||
608         (cRequired && rgcatidReq == NULL)) return E_POINTER;
609
610     res = StringFromGUID2(rclsid, keyname + 6, 39);
611     if (FAILED(res)) return res;
612
613     categories = COMCAT_PrepareClassCategories(cImplemented, rgcatidImpl,
614                                                cRequired, rgcatidReq);
615     if (categories == NULL) return E_OUTOFMEMORY;
616
617     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &key);
618     if (res == ERROR_SUCCESS) {
619         res = COMCAT_IsClassOfCategories(key, categories);
620         RegCloseKey(key);
621     } else res = S_FALSE;
622
623     HeapFree(GetProcessHeap(), 0, categories);
624
625     return res;
626 }
627
628 /**********************************************************************
629  * COMCAT_ICatInformation_EnumImplCategoriesOfClass
630  */
631 static HRESULT WINAPI COMCAT_ICatInformation_EnumImplCategoriesOfClass(
632     LPCATINFORMATION iface,
633     REFCLSID rclsid,
634     LPENUMCATID *ppenumCATID)
635 {
636     static const WCHAR postfix[24] = { '\\', 'I', 'm', 'p', 'l', 'e', 'm', 'e',
637                           'n', 't', 'e', 'd', ' ', 'C', 'a', 't',
638                           'e', 'g', 'o', 'r', 'i', 'e', 's', 0 };
639
640     TRACE("%s\n",debugstr_guid(rclsid));
641
642     if (rclsid == NULL || ppenumCATID == NULL)
643         return E_POINTER;
644
645     *ppenumCATID = COMCAT_CATID_IEnumGUID_Construct(rclsid, postfix);
646     if (*ppenumCATID == NULL) return E_OUTOFMEMORY;
647     return S_OK;
648 }
649
650 /**********************************************************************
651  * COMCAT_ICatInformation_EnumReqCategoriesOfClass
652  */
653 static HRESULT WINAPI COMCAT_ICatInformation_EnumReqCategoriesOfClass(
654     LPCATINFORMATION iface,
655     REFCLSID rclsid,
656     LPENUMCATID *ppenumCATID)
657 {
658     static const WCHAR postfix[21] = { '\\', 'R', 'e', 'q', 'u', 'i', 'r', 'e',
659                           'd', ' ', 'C', 'a', 't', 'e', 'g', 'o',
660                           'r', 'i', 'e', 's', 0 };
661
662     TRACE("%s\n",debugstr_guid(rclsid));
663
664     if (rclsid == NULL || ppenumCATID == NULL)
665         return E_POINTER;
666
667     *ppenumCATID = COMCAT_CATID_IEnumGUID_Construct(rclsid, postfix);
668     if (*ppenumCATID == NULL) return E_OUTOFMEMORY;
669     return S_OK;
670 }
671
672 /**********************************************************************
673  * COMCAT_ICatRegister_Vtbl
674  */
675 static const ICatRegisterVtbl COMCAT_ICatRegister_Vtbl =
676 {
677     COMCAT_ICatRegister_QueryInterface,
678     COMCAT_ICatRegister_AddRef,
679     COMCAT_ICatRegister_Release,
680     COMCAT_ICatRegister_RegisterCategories,
681     COMCAT_ICatRegister_UnRegisterCategories,
682     COMCAT_ICatRegister_RegisterClassImplCategories,
683     COMCAT_ICatRegister_UnRegisterClassImplCategories,
684     COMCAT_ICatRegister_RegisterClassReqCategories,
685     COMCAT_ICatRegister_UnRegisterClassReqCategories
686 };
687
688
689 /**********************************************************************
690  * COMCAT_ICatInformation_Vtbl
691  */
692 static const ICatInformationVtbl COMCAT_ICatInformation_Vtbl =
693 {
694     COMCAT_ICatInformation_QueryInterface,
695     COMCAT_ICatInformation_AddRef,
696     COMCAT_ICatInformation_Release,
697     COMCAT_ICatInformation_EnumCategories,
698     COMCAT_ICatInformation_GetCategoryDesc,
699     COMCAT_ICatInformation_EnumClassesOfCategories,
700     COMCAT_ICatInformation_IsClassOfCategories,
701     COMCAT_ICatInformation_EnumImplCategoriesOfClass,
702     COMCAT_ICatInformation_EnumReqCategoriesOfClass
703 };
704
705 /**********************************************************************
706  * static ComCatMgr instance
707  */
708 static ComCatMgrImpl COMCAT_ComCatMgr =
709 {
710     &COMCAT_ICatRegister_Vtbl,
711     &COMCAT_ICatInformation_Vtbl
712 };
713
714 /**********************************************************************
715  * COMCAT_IClassFactory_QueryInterface (also IUnknown)
716  */
717 static HRESULT WINAPI COMCAT_IClassFactory_QueryInterface(
718     LPCLASSFACTORY iface,
719     REFIID riid,
720     LPVOID *ppvObj)
721 {
722     TRACE("%s\n",debugstr_guid(riid));
723
724     if (ppvObj == NULL) return E_POINTER;
725
726     if (IsEqualGUID(riid, &IID_IUnknown) ||
727         IsEqualGUID(riid, &IID_IClassFactory))
728     {
729         *ppvObj = iface;
730         IUnknown_AddRef(iface);
731         return S_OK;
732     }
733
734     return E_NOINTERFACE;
735 }
736
737 /**********************************************************************
738  * COMCAT_IClassFactory_AddRef (also IUnknown)
739  */
740 static ULONG WINAPI COMCAT_IClassFactory_AddRef(LPCLASSFACTORY iface)
741 {
742     return 2; /* non-heap based object */
743 }
744
745 /**********************************************************************
746  * COMCAT_IClassFactory_Release (also IUnknown)
747  */
748 static ULONG WINAPI COMCAT_IClassFactory_Release(LPCLASSFACTORY iface)
749 {
750     return 1; /* non-heap based object */
751 }
752
753 /**********************************************************************
754  * COMCAT_IClassFactory_CreateInstance
755  */
756 static HRESULT WINAPI COMCAT_IClassFactory_CreateInstance(
757     LPCLASSFACTORY iface,
758     LPUNKNOWN pUnkOuter,
759     REFIID riid,
760     LPVOID *ppvObj)
761 {
762     HRESULT res;
763     TRACE("%s\n",debugstr_guid(riid));
764
765     if (ppvObj == NULL) return E_POINTER;
766
767     /* Don't support aggregation (Windows doesn't) */
768     if (pUnkOuter != NULL) return CLASS_E_NOAGGREGATION;
769
770     res = IUnknown_QueryInterface((LPUNKNOWN)&COMCAT_ComCatMgr, riid, ppvObj);
771     if (SUCCEEDED(res)) {
772         return res;
773     }
774
775     return CLASS_E_CLASSNOTAVAILABLE;
776 }
777
778 /**********************************************************************
779  * COMCAT_IClassFactory_LockServer
780  */
781 static HRESULT WINAPI COMCAT_IClassFactory_LockServer(
782     LPCLASSFACTORY iface,
783     BOOL fLock)
784 {
785     FIXME("(%d), stub!\n",fLock);
786     return S_OK;
787 }
788
789 /**********************************************************************
790  * static ClassFactory instance
791  */
792 static const IClassFactoryVtbl ComCatCFVtbl =
793 {
794     COMCAT_IClassFactory_QueryInterface,
795     COMCAT_IClassFactory_AddRef,
796     COMCAT_IClassFactory_Release,
797     COMCAT_IClassFactory_CreateInstance,
798     COMCAT_IClassFactory_LockServer
799 };
800
801 static const IClassFactoryVtbl *ComCatCF = &ComCatCFVtbl;
802
803 HRESULT ComCatCF_Create(REFIID riid, LPVOID *ppv)
804 {
805     return IClassFactory_QueryInterface((IClassFactory *)&ComCatCF, riid, ppv);
806 }
807
808 /**********************************************************************
809  * IEnumCATEGORYINFO implementation
810  *
811  * This implementation is not thread-safe.  The manager itself is, but
812  * I can't imagine a valid use of an enumerator in several threads.
813  */
814 typedef struct
815 {
816     const IEnumCATEGORYINFOVtbl *lpVtbl;
817     LONG  ref;
818     LCID  lcid;
819     HKEY  key;
820     DWORD next_index;
821 } IEnumCATEGORYINFOImpl;
822
823 static ULONG WINAPI COMCAT_IEnumCATEGORYINFO_AddRef(LPENUMCATEGORYINFO iface)
824 {
825     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
826
827     TRACE("\n");
828
829     return InterlockedIncrement(&This->ref);
830 }
831
832 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_QueryInterface(
833     LPENUMCATEGORYINFO iface,
834     REFIID riid,
835     LPVOID *ppvObj)
836 {
837     TRACE("%s\n",debugstr_guid(riid));
838
839     if (ppvObj == NULL) return E_POINTER;
840
841     if (IsEqualGUID(riid, &IID_IUnknown) ||
842         IsEqualGUID(riid, &IID_IEnumCATEGORYINFO))
843     {
844         *ppvObj = iface;
845         COMCAT_IEnumCATEGORYINFO_AddRef(iface);
846         return S_OK;
847     }
848
849     return E_NOINTERFACE;
850 }
851
852 static ULONG WINAPI COMCAT_IEnumCATEGORYINFO_Release(LPENUMCATEGORYINFO iface)
853 {
854     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
855     ULONG ref;
856
857     TRACE("\n");
858
859     ref = InterlockedDecrement(&This->ref);
860     if (ref == 0) {
861         if (This->key) RegCloseKey(This->key);
862         HeapFree(GetProcessHeap(), 0, This);
863         return 0;
864     }
865     return ref;
866 }
867
868 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Next(
869     LPENUMCATEGORYINFO iface,
870     ULONG celt,
871     CATEGORYINFO *rgelt,
872     ULONG *pceltFetched)
873 {
874     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
875     ULONG fetched = 0;
876
877     TRACE("\n");
878
879     if (rgelt == NULL) return E_POINTER;
880
881     if (This->key) while (fetched < celt) {
882         LSTATUS res;
883         HRESULT hr;
884         WCHAR catid[39];
885         DWORD cName = 39;
886         HKEY subkey;
887
888         res = RegEnumKeyExW(This->key, This->next_index, catid, &cName,
889                             NULL, NULL, NULL, NULL);
890         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
891         ++(This->next_index);
892
893         hr = CLSIDFromString(catid, &rgelt->catid);
894         if (FAILED(hr)) continue;
895
896         res = RegOpenKeyExW(This->key, catid, 0, KEY_READ, &subkey);
897         if (res != ERROR_SUCCESS) continue;
898
899         hr = COMCAT_GetCategoryDesc(subkey, This->lcid,
900                                     rgelt->szDescription, 128);
901         RegCloseKey(subkey);
902         if (FAILED(hr)) continue;
903
904         rgelt->lcid = This->lcid;
905         ++fetched;
906         ++rgelt;
907     }
908
909     if (pceltFetched) *pceltFetched = fetched;
910     return fetched == celt ? S_OK : S_FALSE;
911 }
912
913 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Skip(
914     LPENUMCATEGORYINFO iface,
915     ULONG celt)
916 {
917     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
918
919     TRACE("\n");
920
921     This->next_index += celt;
922     /* This should return S_FALSE when there aren't celt elems to skip. */
923     return S_OK;
924 }
925
926 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Reset(LPENUMCATEGORYINFO iface)
927 {
928     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
929
930     TRACE("\n");
931
932     This->next_index = 0;
933     return S_OK;
934 }
935
936 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Clone(
937     LPENUMCATEGORYINFO iface,
938     IEnumCATEGORYINFO **ppenum)
939 {
940     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
941     static const WCHAR keyname[] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
942                                      't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
943                                      'r', 'i', 'e', 's', 0 };
944     IEnumCATEGORYINFOImpl *new_this;
945
946     TRACE("\n");
947
948     if (ppenum == NULL) return E_POINTER;
949
950     new_this = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumCATEGORYINFOImpl));
951     if (new_this == NULL) return E_OUTOFMEMORY;
952
953     new_this->lpVtbl = This->lpVtbl;
954     new_this->ref = 1;
955     new_this->lcid = This->lcid;
956     /* FIXME: could we more efficiently use DuplicateHandle? */
957     RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &new_this->key);
958     new_this->next_index = This->next_index;
959
960     *ppenum = (LPENUMCATEGORYINFO)new_this;
961     return S_OK;
962 }
963
964 static const IEnumCATEGORYINFOVtbl COMCAT_IEnumCATEGORYINFO_Vtbl =
965 {
966     COMCAT_IEnumCATEGORYINFO_QueryInterface,
967     COMCAT_IEnumCATEGORYINFO_AddRef,
968     COMCAT_IEnumCATEGORYINFO_Release,
969     COMCAT_IEnumCATEGORYINFO_Next,
970     COMCAT_IEnumCATEGORYINFO_Skip,
971     COMCAT_IEnumCATEGORYINFO_Reset,
972     COMCAT_IEnumCATEGORYINFO_Clone
973 };
974
975 static LPENUMCATEGORYINFO COMCAT_IEnumCATEGORYINFO_Construct(LCID lcid)
976 {
977     IEnumCATEGORYINFOImpl *This;
978
979     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumCATEGORYINFOImpl));
980     if (This) {
981         static const WCHAR keyname[] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
982                                          't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
983                                          'r', 'i', 'e', 's', 0 };
984
985         This->lpVtbl = &COMCAT_IEnumCATEGORYINFO_Vtbl;
986         This->lcid = lcid;
987         RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &This->key);
988     }
989     return (LPENUMCATEGORYINFO)This;
990 }
991
992 /**********************************************************************
993  * ClassesOfCategories IEnumCLSID (IEnumGUID) implementation
994  *
995  * This implementation is not thread-safe.  The manager itself is, but
996  * I can't imagine a valid use of an enumerator in several threads.
997  */
998 typedef struct
999 {
1000     const IEnumGUIDVtbl *lpVtbl;
1001     LONG  ref;
1002     struct class_categories *categories;
1003     HKEY  key;
1004     DWORD next_index;
1005 } CLSID_IEnumGUIDImpl;
1006
1007 static ULONG WINAPI COMCAT_CLSID_IEnumGUID_AddRef(LPENUMGUID iface)
1008 {
1009     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
1010     TRACE("\n");
1011
1012     return InterlockedIncrement(&This->ref);
1013 }
1014
1015 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_QueryInterface(
1016     LPENUMGUID iface,
1017     REFIID riid,
1018     LPVOID *ppvObj)
1019 {
1020     TRACE("%s\n",debugstr_guid(riid));
1021
1022     if (ppvObj == NULL) return E_POINTER;
1023
1024     if (IsEqualGUID(riid, &IID_IUnknown) ||
1025         IsEqualGUID(riid, &IID_IEnumGUID))
1026     {
1027         *ppvObj = iface;
1028         COMCAT_CLSID_IEnumGUID_AddRef(iface);
1029         return S_OK;
1030     }
1031
1032     return E_NOINTERFACE;
1033 }
1034
1035 static ULONG WINAPI COMCAT_CLSID_IEnumGUID_Release(LPENUMGUID iface)
1036 {
1037     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
1038     ULONG ref;
1039
1040     TRACE("\n");
1041
1042     ref = InterlockedDecrement(&This->ref);
1043     if (ref == 0) {
1044         if (This->key) RegCloseKey(This->key);
1045         HeapFree(GetProcessHeap(), 0, This->categories);
1046         HeapFree(GetProcessHeap(), 0, This);
1047         return 0;
1048     }
1049     return ref;
1050 }
1051
1052 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Next(
1053     LPENUMGUID iface,
1054     ULONG celt,
1055     GUID *rgelt,
1056     ULONG *pceltFetched)
1057 {
1058     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
1059     ULONG fetched = 0;
1060
1061     TRACE("\n");
1062
1063     if (rgelt == NULL) return E_POINTER;
1064
1065     if (This->key) while (fetched < celt) {
1066         LSTATUS res;
1067         HRESULT hr;
1068         WCHAR clsid[39];
1069         DWORD cName = 39;
1070         HKEY subkey;
1071
1072         res = RegEnumKeyExW(This->key, This->next_index, clsid, &cName,
1073                             NULL, NULL, NULL, NULL);
1074         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
1075         ++(This->next_index);
1076
1077         hr = CLSIDFromString(clsid, rgelt);
1078         if (FAILED(hr)) continue;
1079
1080         res = RegOpenKeyExW(This->key, clsid, 0, KEY_READ, &subkey);
1081         if (res != ERROR_SUCCESS) continue;
1082
1083         hr = COMCAT_IsClassOfCategories(subkey, This->categories);
1084         RegCloseKey(subkey);
1085         if (hr != S_OK) continue;
1086
1087         ++fetched;
1088         ++rgelt;
1089     }
1090
1091     if (pceltFetched) *pceltFetched = fetched;
1092     return fetched == celt ? S_OK : S_FALSE;
1093 }
1094
1095 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Skip(
1096     LPENUMGUID iface,
1097     ULONG celt)
1098 {
1099     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
1100
1101     TRACE("\n");
1102
1103     This->next_index += celt;
1104     FIXME("Never returns S_FALSE\n");
1105     return S_OK;
1106 }
1107
1108 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Reset(LPENUMGUID iface)
1109 {
1110     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
1111
1112     TRACE("\n");
1113
1114     This->next_index = 0;
1115     return S_OK;
1116 }
1117
1118 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Clone(
1119     LPENUMGUID iface,
1120     IEnumGUID **ppenum)
1121 {
1122     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
1123     static const WCHAR keyname[] = { 'C', 'L', 'S', 'I', 'D', 0 };
1124     CLSID_IEnumGUIDImpl *new_this;
1125     DWORD size;
1126
1127     TRACE("\n");
1128
1129     if (ppenum == NULL) return E_POINTER;
1130
1131     new_this = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLSID_IEnumGUIDImpl));
1132     if (new_this == NULL) return E_OUTOFMEMORY;
1133
1134     new_this->lpVtbl = This->lpVtbl;
1135     new_this->ref = 1;
1136     size = HeapSize(GetProcessHeap(), 0, This->categories);
1137     new_this->categories =
1138         HeapAlloc(GetProcessHeap(), 0, size);
1139     if (new_this->categories == NULL) {
1140         HeapFree(GetProcessHeap(), 0, new_this);
1141         return E_OUTOFMEMORY;
1142     }
1143     memcpy(new_this->categories, This->categories, size);
1144     /* FIXME: could we more efficiently use DuplicateHandle? */
1145     RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &new_this->key);
1146     new_this->next_index = This->next_index;
1147
1148     *ppenum = (LPENUMGUID)new_this;
1149     return S_OK;
1150 }
1151
1152 static const IEnumGUIDVtbl COMCAT_CLSID_IEnumGUID_Vtbl =
1153 {
1154     COMCAT_CLSID_IEnumGUID_QueryInterface,
1155     COMCAT_CLSID_IEnumGUID_AddRef,
1156     COMCAT_CLSID_IEnumGUID_Release,
1157     COMCAT_CLSID_IEnumGUID_Next,
1158     COMCAT_CLSID_IEnumGUID_Skip,
1159     COMCAT_CLSID_IEnumGUID_Reset,
1160     COMCAT_CLSID_IEnumGUID_Clone
1161 };
1162
1163 static LPENUMGUID COMCAT_CLSID_IEnumGUID_Construct(struct class_categories *categories)
1164 {
1165     CLSID_IEnumGUIDImpl *This;
1166
1167     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLSID_IEnumGUIDImpl));
1168     if (This) {
1169         static const WCHAR keyname[] = { 'C', 'L', 'S', 'I', 'D', 0 };
1170
1171         This->lpVtbl = &COMCAT_CLSID_IEnumGUID_Vtbl;
1172         This->categories = categories;
1173         RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &This->key);
1174     }
1175     return (LPENUMGUID)This;
1176 }
1177
1178 /**********************************************************************
1179  * CategoriesOfClass IEnumCATID (IEnumGUID) implementation
1180  *
1181  * This implementation is not thread-safe.  The manager itself is, but
1182  * I can't imagine a valid use of an enumerator in several threads.
1183  */
1184 typedef struct
1185 {
1186     const IEnumGUIDVtbl *lpVtbl;
1187     LONG  ref;
1188     WCHAR keyname[68];
1189     HKEY  key;
1190     DWORD next_index;
1191 } CATID_IEnumGUIDImpl;
1192
1193 static ULONG WINAPI COMCAT_CATID_IEnumGUID_AddRef(LPENUMGUID iface)
1194 {
1195     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
1196     TRACE("\n");
1197
1198     return InterlockedIncrement(&This->ref);
1199 }
1200
1201 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_QueryInterface(
1202     LPENUMGUID iface,
1203     REFIID riid,
1204     LPVOID *ppvObj)
1205 {
1206     TRACE("%s\n",debugstr_guid(riid));
1207
1208     if (ppvObj == NULL) return E_POINTER;
1209
1210     if (IsEqualGUID(riid, &IID_IUnknown) ||
1211         IsEqualGUID(riid, &IID_IEnumGUID))
1212     {
1213         *ppvObj = iface;
1214         COMCAT_CATID_IEnumGUID_AddRef(iface);
1215         return S_OK;
1216     }
1217
1218     return E_NOINTERFACE;
1219 }
1220
1221 static ULONG WINAPI COMCAT_CATID_IEnumGUID_Release(LPENUMGUID iface)
1222 {
1223     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
1224     ULONG ref;
1225
1226     TRACE("\n");
1227
1228     ref = InterlockedDecrement(&This->ref);
1229     if (ref == 0) {
1230         if (This->key) RegCloseKey(This->key);
1231         HeapFree(GetProcessHeap(), 0, This);
1232         return 0;
1233     }
1234     return ref;
1235 }
1236
1237 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Next(
1238     LPENUMGUID iface,
1239     ULONG celt,
1240     GUID *rgelt,
1241     ULONG *pceltFetched)
1242 {
1243     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
1244     ULONG fetched = 0;
1245
1246     TRACE("\n");
1247
1248     if (rgelt == NULL) return E_POINTER;
1249
1250     if (This->key) while (fetched < celt) {
1251         LSTATUS res;
1252         HRESULT hr;
1253         WCHAR catid[39];
1254         DWORD cName = 39;
1255
1256         res = RegEnumKeyExW(This->key, This->next_index, catid, &cName,
1257                             NULL, NULL, NULL, NULL);
1258         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
1259         ++(This->next_index);
1260
1261         hr = CLSIDFromString(catid, rgelt);
1262         if (FAILED(hr)) continue;
1263
1264         ++fetched;
1265         ++rgelt;
1266     }
1267
1268     if (pceltFetched) *pceltFetched = fetched;
1269     return fetched == celt ? S_OK : S_FALSE;
1270 }
1271
1272 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Skip(
1273     LPENUMGUID iface,
1274     ULONG celt)
1275 {
1276     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
1277
1278     TRACE("\n");
1279
1280     This->next_index += celt;
1281     FIXME("Never returns S_FALSE\n");
1282     return S_OK;
1283 }
1284
1285 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Reset(LPENUMGUID iface)
1286 {
1287     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
1288
1289     TRACE("\n");
1290
1291     This->next_index = 0;
1292     return S_OK;
1293 }
1294
1295 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Clone(
1296     LPENUMGUID iface,
1297     IEnumGUID **ppenum)
1298 {
1299     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
1300     CATID_IEnumGUIDImpl *new_this;
1301
1302     TRACE("\n");
1303
1304     if (ppenum == NULL) return E_POINTER;
1305
1306     new_this = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CATID_IEnumGUIDImpl));
1307     if (new_this == NULL) return E_OUTOFMEMORY;
1308
1309     new_this->lpVtbl = This->lpVtbl;
1310     new_this->ref = 1;
1311     lstrcpyW(new_this->keyname, This->keyname);
1312     /* FIXME: could we more efficiently use DuplicateHandle? */
1313     RegOpenKeyExW(HKEY_CLASSES_ROOT, new_this->keyname, 0, KEY_READ, &new_this->key);
1314     new_this->next_index = This->next_index;
1315
1316     *ppenum = (LPENUMGUID)new_this;
1317     return S_OK;
1318 }
1319
1320 static const IEnumGUIDVtbl COMCAT_CATID_IEnumGUID_Vtbl =
1321 {
1322     COMCAT_CATID_IEnumGUID_QueryInterface,
1323     COMCAT_CATID_IEnumGUID_AddRef,
1324     COMCAT_CATID_IEnumGUID_Release,
1325     COMCAT_CATID_IEnumGUID_Next,
1326     COMCAT_CATID_IEnumGUID_Skip,
1327     COMCAT_CATID_IEnumGUID_Reset,
1328     COMCAT_CATID_IEnumGUID_Clone
1329 };
1330
1331 static LPENUMGUID COMCAT_CATID_IEnumGUID_Construct(
1332     REFCLSID rclsid, LPCWSTR postfix)
1333 {
1334     CATID_IEnumGUIDImpl *This;
1335
1336     This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CATID_IEnumGUIDImpl));
1337     if (This) {
1338         WCHAR prefix[6] = { 'C', 'L', 'S', 'I', 'D', '\\' };
1339
1340         This->lpVtbl = &COMCAT_CATID_IEnumGUID_Vtbl;
1341         memcpy(This->keyname, prefix, sizeof(prefix));
1342         StringFromGUID2(rclsid, This->keyname + 6, 39);
1343         lstrcpyW(This->keyname + 44, postfix);
1344         RegOpenKeyExW(HKEY_CLASSES_ROOT, This->keyname, 0, KEY_READ, &This->key);
1345     }
1346     return (LPENUMGUID)This;
1347 }