git.oblomov.eu Git - wine/blob - dlls/comcat/information.c

   1 /*
   2  *      ComCatMgr ICatInformation implementation for comcat.dll
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <string.h>
  22 #include "comcat_private.h"
  23
  24 #include "wine/debug.h"
  25
  26 WINE_DEFAULT_DEBUG_CHANNEL(ole);
  27
  28 static LPENUMCATEGORYINFO COMCAT_IEnumCATEGORYINFO_Construct(LCID lcid);
  29 static HRESULT COMCAT_GetCategoryDesc(HKEY key, LCID lcid, PWCHAR pszDesc,
  30                                       ULONG buf_wchars);
  31
  32 struct class_categories {
  33     LPCWSTR impl_strings;
  34     LPCWSTR req_strings;
  35 };
  36
  37 static struct class_categories *COMCAT_PrepareClassCategories(
  38     ULONG impl_count, CATID *impl_catids, ULONG req_count, CATID *req_catids);
  39 static HRESULT COMCAT_IsClassOfCategories(
  40     HKEY key, struct class_categories const* class_categories);
  41 static LPENUMGUID COMCAT_CLSID_IEnumGUID_Construct(
  42     struct class_categories const* class_categories);
  43 static LPENUMGUID COMCAT_CATID_IEnumGUID_Construct(
  44     REFCLSID rclsid, LPCWSTR impl_req);
  45
  46 /**********************************************************************
  47  * COMCAT_ICatInformation_QueryInterface
  48  */
  49 static HRESULT WINAPI COMCAT_ICatInformation_QueryInterface(
  50     LPCATINFORMATION iface,
  51     REFIID riid,
  52     LPVOID *ppvObj)
  53 {
  54     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface);
  55     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
  56
  57     if (This == NULL || ppvObj == NULL) return E_POINTER;
  58
  59     return IUnknown_QueryInterface((LPUNKNOWN)&This->unkVtbl, riid, ppvObj);
  60 }
  61
  62 /**********************************************************************
  63  * COMCAT_ICatInformation_AddRef
  64  */
  65 static ULONG WINAPI COMCAT_ICatInformation_AddRef(LPCATINFORMATION iface)
  66 {
  67     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface);
  68     TRACE("\n");
  69
  70     if (This == NULL) return E_POINTER;
  71
  72     return IUnknown_AddRef((LPUNKNOWN)&This->unkVtbl);
  73 }
  74
  75 /**********************************************************************
  76  * COMCAT_ICatInformation_Release
  77  */
  78 static ULONG WINAPI COMCAT_ICatInformation_Release(LPCATINFORMATION iface)
  79 {
  80     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface);
  81     TRACE("\n");
  82
  83     if (This == NULL) return E_POINTER;
  84
  85     return IUnknown_Release((LPUNKNOWN)&This->unkVtbl);
  86 }
  87
  88 /**********************************************************************
  89  * COMCAT_ICatInformation_EnumCategories
  90  */
  91 static HRESULT WINAPI COMCAT_ICatInformation_EnumCategories(
  92     LPCATINFORMATION iface,
  93     LCID lcid,
  94     LPENUMCATEGORYINFO *ppenumCatInfo)
  95 {
  96 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
  97     TRACE("\n");
  98
  99     if (iface == NULL || ppenumCatInfo == NULL) return E_POINTER;
 100
 101     *ppenumCatInfo = COMCAT_IEnumCATEGORYINFO_Construct(lcid);
 102     if (*ppenumCatInfo == NULL) return E_OUTOFMEMORY;
 103     IEnumCATEGORYINFO_AddRef(*ppenumCatInfo);
 104     return S_OK;
 105 }
 106
 107 /**********************************************************************
 108  * COMCAT_ICatInformation_GetCategoryDesc
 109  */
 110 static HRESULT WINAPI COMCAT_ICatInformation_GetCategoryDesc(
 111     LPCATINFORMATION iface,
 112     REFCATID rcatid,
 113     LCID lcid,
 114     PWCHAR *ppszDesc)
 115 {
 116 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
 117     WCHAR keyname[60] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
 118                           't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
 119                           'r', 'i', 'e', 's', '\\', 0 };
 120     HKEY key;
 121     HRESULT res;
 122
 123     TRACE("\n\tCATID:\t%s\n\tLCID:\t%lX\n",debugstr_guid(rcatid), lcid);
 124
 125     if (rcatid == NULL || ppszDesc == NULL) return E_INVALIDARG;
 126
 127     /* Open the key for this category. */
 128     if (!StringFromGUID2(rcatid, keyname + 21, 39)) return E_FAIL;
 129     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &key);
 130     if (res != ERROR_SUCCESS) return CAT_E_CATIDNOEXIST;
 131
 132     /* Allocate a sensible amount of memory for the description. */
 133     *ppszDesc = (PWCHAR) CoTaskMemAlloc(128 * sizeof(WCHAR));
 134     if (*ppszDesc == NULL) {
 135         RegCloseKey(key);
 136         return E_OUTOFMEMORY;
 137     }
 138
 139     /* Get the description, and make sure it's null terminated. */
 140     res = COMCAT_GetCategoryDesc(key, lcid, *ppszDesc, 128);
 141     RegCloseKey(key);
 142     if (FAILED(res)) {
 143         CoTaskMemFree(*ppszDesc);
 144         return res;
 145     }
 146
 147     return S_OK;
 148 }
 149
 150 /**********************************************************************
 151  * COMCAT_ICatInformation_EnumClassesOfCategories
 152  */
 153 static HRESULT WINAPI COMCAT_ICatInformation_EnumClassesOfCategories(
 154     LPCATINFORMATION iface,
 155     ULONG cImplemented,
 156     CATID *rgcatidImpl,
 157     ULONG cRequired,
 158     CATID *rgcatidReq,
 159     LPENUMCLSID *ppenumCLSID)
 160 {
 161 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
 162     struct class_categories *categories;
 163
 164     TRACE("\n");
 165
 166     if (iface == NULL || ppenumCLSID == NULL ||
 167         (cImplemented && rgcatidImpl == NULL) ||
 168         (cRequired && rgcatidReq == NULL)) return E_POINTER;
 169
 170     categories = COMCAT_PrepareClassCategories(cImplemented, rgcatidImpl,
 171                                                cRequired, rgcatidReq);
 172     if (categories == NULL) return E_OUTOFMEMORY;
 173     *ppenumCLSID = COMCAT_CLSID_IEnumGUID_Construct(categories);
 174     if (*ppenumCLSID == NULL) {
 175         HeapFree(GetProcessHeap(), 0, categories);
 176         return E_OUTOFMEMORY;
 177     }
 178     IEnumGUID_AddRef(*ppenumCLSID);
 179     return S_OK;
 180 }
 181
 182 /**********************************************************************
 183  * COMCAT_ICatInformation_IsClassOfCategories
 184  */
 185 static HRESULT WINAPI COMCAT_ICatInformation_IsClassOfCategories(
 186     LPCATINFORMATION iface,
 187     REFCLSID rclsid,
 188     ULONG cImplemented,
 189     CATID *rgcatidImpl,
 190     ULONG cRequired,
 191     CATID *rgcatidReq)
 192 {
 193 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
 194     WCHAR keyname[45] = { 'C', 'L', 'S', 'I', 'D', '\\', 0 };
 195     HRESULT res;
 196     struct class_categories *categories;
 197     HKEY key;
 198
 199     if (WINE_TRACE_ON(ole)) {
 200         ULONG count;
 201         TRACE("\n\tCLSID:\t%s\n\tImplemented %lu\n",debugstr_guid(rclsid),cImplemented);
 202         for (count = 0; count < cImplemented; ++count)
 203             TRACE("\t\t%s\n",debugstr_guid(&rgcatidImpl[count]));
 204         TRACE("\tRequired %lu\n",cRequired);
 205         for (count = 0; count < cRequired; ++count)
 206             TRACE("\t\t%s\n",debugstr_guid(&rgcatidReq[count]));
 207     }
 208
 209     if ((cImplemented && rgcatidImpl == NULL) ||
 210         (cRequired && rgcatidReq == NULL)) return E_POINTER;
 211
 212     res = StringFromGUID2(rclsid, keyname + 6, 39);
 213     if (FAILED(res)) return res;
 214
 215     categories = COMCAT_PrepareClassCategories(cImplemented, rgcatidImpl,
 216                                                cRequired, rgcatidReq);
 217     if (categories == NULL) return E_OUTOFMEMORY;
 218
 219     res = RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &key);
 220     if (res == ERROR_SUCCESS) {
 221         res = COMCAT_IsClassOfCategories(key, categories);
 222         RegCloseKey(key);
 223     } else res = S_FALSE;
 224
 225     HeapFree(GetProcessHeap(), 0, categories);
 226
 227     return res;
 228 }
 229
 230 /**********************************************************************
 231  * COMCAT_ICatInformation_EnumImplCategoriesOfClass
 232  */
 233 static HRESULT WINAPI COMCAT_ICatInformation_EnumImplCategoriesOfClass(
 234     LPCATINFORMATION iface,
 235     REFCLSID rclsid,
 236     LPENUMCATID *ppenumCATID)
 237 {
 238 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
 239     WCHAR postfix[24] = { '\\', 'I', 'm', 'p', 'l', 'e', 'm', 'e',
 240                           'n', 't', 'e', 'd', ' ', 'C', 'a', 't',
 241                           'e', 'g', 'o', 'r', 'i', 'e', 's', 0 };
 242
 243     TRACE("\n\tCLSID:\t%s\n",debugstr_guid(rclsid));
 244
 245     if (iface == NULL || rclsid == NULL || ppenumCATID == NULL)
 246         return E_POINTER;
 247
 248     *ppenumCATID = COMCAT_CATID_IEnumGUID_Construct(rclsid, postfix);
 249     if (*ppenumCATID == NULL) return E_OUTOFMEMORY;
 250     return S_OK;
 251 }
 252
 253 /**********************************************************************
 254  * COMCAT_ICatInformation_EnumReqCategoriesOfClass
 255  */
 256 static HRESULT WINAPI COMCAT_ICatInformation_EnumReqCategoriesOfClass(
 257     LPCATINFORMATION iface,
 258     REFCLSID rclsid,
 259     LPENUMCATID *ppenumCATID)
 260 {
 261 /*     ICOM_THIS_MULTI(ComCatMgrImpl, infVtbl, iface); */
 262     WCHAR postfix[21] = { '\\', 'R', 'e', 'q', 'u', 'i', 'r', 'e',
 263                           'd', ' ', 'C', 'a', 't', 'e', 'g', 'o',
 264                           'r', 'i', 'e', 's', 0 };
 265
 266     TRACE("\n\tCLSID:\t%s\n",debugstr_guid(rclsid));
 267
 268     if (iface == NULL || rclsid == NULL || ppenumCATID == NULL)
 269         return E_POINTER;
 270
 271     *ppenumCATID = COMCAT_CATID_IEnumGUID_Construct(rclsid, postfix);
 272     if (*ppenumCATID == NULL) return E_OUTOFMEMORY;
 273     return S_OK;
 274 }
 275
 276 /**********************************************************************
 277  * COMCAT_ICatInformation_Vtbl
 278  */
 279 ICatInformationVtbl COMCAT_ICatInformation_Vtbl =
 280 {
 281     COMCAT_ICatInformation_QueryInterface,
 282     COMCAT_ICatInformation_AddRef,
 283     COMCAT_ICatInformation_Release,
 284     COMCAT_ICatInformation_EnumCategories,
 285     COMCAT_ICatInformation_GetCategoryDesc,
 286     COMCAT_ICatInformation_EnumClassesOfCategories,
 287     COMCAT_ICatInformation_IsClassOfCategories,
 288     COMCAT_ICatInformation_EnumImplCategoriesOfClass,
 289     COMCAT_ICatInformation_EnumReqCategoriesOfClass
 290 };
 291
 292 /**********************************************************************
 293  * IEnumCATEGORYINFO implementation
 294  *
 295  * This implementation is not thread-safe.  The manager itself is, but
 296  * I can't imagine a valid use of an enumerator in several threads.
 297  */
 298 typedef struct
 299 {
 300     IEnumCATEGORYINFOVtbl *lpVtbl;
 301     DWORD ref;
 302     LCID  lcid;
 303     HKEY  key;
 304     DWORD next_index;
 305 } IEnumCATEGORYINFOImpl;
 306
 307 static ULONG WINAPI COMCAT_IEnumCATEGORYINFO_AddRef(LPENUMCATEGORYINFO iface)
 308 {
 309     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 310
 311     TRACE("\n");
 312
 313     if (This == NULL) return E_POINTER;
 314
 315     return InterlockedIncrement(&This->ref);
 316 }
 317
 318 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_QueryInterface(
 319     LPENUMCATEGORYINFO iface,
 320     REFIID riid,
 321     LPVOID *ppvObj)
 322 {
 323     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 324     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
 325
 326     if (This == NULL || ppvObj == NULL) return E_POINTER;
 327
 328     if (IsEqualGUID(riid, &IID_IUnknown) ||
 329         IsEqualGUID(riid, &IID_IEnumCATEGORYINFO))
 330     {
 331         *ppvObj = (LPVOID)iface;
 332         COMCAT_IEnumCATEGORYINFO_AddRef(iface);
 333         return S_OK;
 334     }
 335
 336     return E_NOINTERFACE;
 337 }
 338
 339 static ULONG WINAPI COMCAT_IEnumCATEGORYINFO_Release(LPENUMCATEGORYINFO iface)
 340 {
 341     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 342     ULONG ref;
 343
 344     TRACE("\n");
 345
 346     if (This == NULL) return E_POINTER;
 347
 348     ref = InterlockedDecrement(&This->ref);
 349     if (ref == 0) {
 350         if (This->key) RegCloseKey(This->key);
 351         HeapFree(GetProcessHeap(), 0, This);
 352         return 0;
 353     }
 354     return ref;
 355 }
 356
 357 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Next(
 358     LPENUMCATEGORYINFO iface,
 359     ULONG celt,
 360     CATEGORYINFO *rgelt,
 361     ULONG *pceltFetched)
 362 {
 363     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 364     ULONG fetched = 0;
 365
 366     TRACE("\n");
 367
 368     if (This == NULL || rgelt == NULL) return E_POINTER;
 369
 370     if (This->key) while (fetched < celt) {
 371         HRESULT res;
 372         WCHAR catid[39];
 373         DWORD cName = 39;
 374         HKEY subkey;
 375
 376         res = RegEnumKeyExW(This->key, This->next_index, catid, &cName,
 377                             NULL, NULL, NULL, NULL);
 378         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
 379         ++(This->next_index);
 380
 381         res = CLSIDFromString(catid, &rgelt->catid);
 382         if (FAILED(res)) continue;
 383
 384         res = RegOpenKeyExW(This->key, catid, 0, KEY_READ, &subkey);
 385         if (res != ERROR_SUCCESS) continue;
 386
 387         res = COMCAT_GetCategoryDesc(subkey, This->lcid,
 388                                      rgelt->szDescription, 128);
 389         RegCloseKey(subkey);
 390         if (FAILED(res)) continue;
 391
 392         rgelt->lcid = This->lcid;
 393         ++fetched;
 394         ++rgelt;
 395     }
 396
 397     if (pceltFetched) *pceltFetched = fetched;
 398     return fetched == celt ? S_OK : S_FALSE;
 399 }
 400
 401 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Skip(
 402     LPENUMCATEGORYINFO iface,
 403     ULONG celt)
 404 {
 405     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 406
 407     TRACE("\n");
 408
 409     if (This == NULL) return E_POINTER;
 410     This->next_index += celt;
 411     /* This should return S_FALSE when there aren't celt elems to skip. */
 412     return S_OK;
 413 }
 414
 415 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Reset(LPENUMCATEGORYINFO iface)
 416 {
 417     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 418
 419     TRACE("\n");
 420
 421     if (This == NULL) return E_POINTER;
 422     This->next_index = 0;
 423     return S_OK;
 424 }
 425
 426 static HRESULT WINAPI COMCAT_IEnumCATEGORYINFO_Clone(
 427     LPENUMCATEGORYINFO iface,
 428     IEnumCATEGORYINFO **ppenum)
 429 {
 430     IEnumCATEGORYINFOImpl *This = (IEnumCATEGORYINFOImpl *)iface;
 431     WCHAR keyname[21] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
 432                           't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
 433                           'r', 'i', 'e', 's', 0 };
 434     IEnumCATEGORYINFOImpl *new_this;
 435
 436     TRACE("\n");
 437
 438     if (This == NULL || ppenum == NULL) return E_POINTER;
 439
 440     new_this = (IEnumCATEGORYINFOImpl *) HeapAlloc(
 441         GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumCATEGORYINFOImpl));
 442     if (new_this == NULL) return E_OUTOFMEMORY;
 443
 444     new_this->lpVtbl = This->lpVtbl;
 445     new_this->ref = 1;
 446     new_this->lcid = This->lcid;
 447     /* FIXME: could we more efficiently use DuplicateHandle? */
 448     RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &new_this->key);
 449     new_this->next_index = This->next_index;
 450
 451     *ppenum = (LPENUMCATEGORYINFO)new_this;
 452     return S_OK;
 453 }
 454
 455 IEnumCATEGORYINFOVtbl COMCAT_IEnumCATEGORYINFO_Vtbl =
 456 {
 457     COMCAT_IEnumCATEGORYINFO_QueryInterface,
 458     COMCAT_IEnumCATEGORYINFO_AddRef,
 459     COMCAT_IEnumCATEGORYINFO_Release,
 460     COMCAT_IEnumCATEGORYINFO_Next,
 461     COMCAT_IEnumCATEGORYINFO_Skip,
 462     COMCAT_IEnumCATEGORYINFO_Reset,
 463     COMCAT_IEnumCATEGORYINFO_Clone
 464 };
 465
 466 static LPENUMCATEGORYINFO COMCAT_IEnumCATEGORYINFO_Construct(LCID lcid)
 467 {
 468     IEnumCATEGORYINFOImpl *This;
 469
 470     This = (IEnumCATEGORYINFOImpl *) HeapAlloc(
 471         GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IEnumCATEGORYINFOImpl));
 472     if (This) {
 473         WCHAR keyname[21] = { 'C', 'o', 'm', 'p', 'o', 'n', 'e', 'n',
 474                               't', ' ', 'C', 'a', 't', 'e', 'g', 'o',
 475                               'r', 'i', 'e', 's', 0 };
 476
 477         This->lpVtbl = &COMCAT_IEnumCATEGORYINFO_Vtbl;
 478         This->lcid = lcid;
 479         RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &This->key);
 480     }
 481     return (LPENUMCATEGORYINFO)This;
 482 }
 483
 484 /**********************************************************************
 485  * COMCAT_GetCategoryDesc
 486  */
 487 static HRESULT COMCAT_GetCategoryDesc(HKEY key, LCID lcid, PWCHAR pszDesc,
 488                                       ULONG buf_wchars)
 489 {
 490     WCHAR fmt[4] = { '%', 'l', 'X', 0 };
 491     WCHAR valname[5];
 492     HRESULT res;
 493     DWORD type, size = (buf_wchars - 1) * sizeof(WCHAR);
 494
 495     if (pszDesc == NULL) return E_INVALIDARG;
 496
 497     /* FIXME: lcid comparisons are more complex than this! */
 498     wsprintfW(valname, fmt, lcid);
 499     res = RegQueryValueExW(key, valname, 0, &type, (LPBYTE)pszDesc, &size);
 500     if (res != ERROR_SUCCESS || type != REG_SZ) {
 501         FIXME("Simplified lcid comparison\n");
 502         return CAT_E_NODESCRIPTION;
 503     }
 504     pszDesc[size / sizeof(WCHAR)] = (WCHAR)0;
 505
 506     return S_OK;
 507 }
 508
 509 /**********************************************************************
 510  * COMCAT_PrepareClassCategories
 511  */
 512 static struct class_categories *COMCAT_PrepareClassCategories(
 513     ULONG impl_count, CATID *impl_catids, ULONG req_count, CATID *req_catids)
 514 {
 515     struct class_categories *categories;
 516     WCHAR *strings;
 517
 518     categories = (struct class_categories *)HeapAlloc(
 519         GetProcessHeap(), HEAP_ZERO_MEMORY,
 520         sizeof(struct class_categories) +
 521         ((impl_count + req_count) * 39 + 2) * sizeof(WCHAR));
 522     if (categories == NULL) return categories;
 523
 524     strings = (WCHAR *)(categories + 1);
 525     categories->impl_strings = strings;
 526     while (impl_count--) {
 527         StringFromGUID2(impl_catids++, strings, 39);
 528         strings += 39;
 529     }
 530     *strings++ = 0;
 531
 532     categories->req_strings = strings;
 533     while (req_count--) {
 534         StringFromGUID2(req_catids++, strings, 39);
 535         strings += 39;
 536     }
 537     *strings++ = 0;
 538
 539     return categories;
 540 }
 541
 542 /**********************************************************************
 543  * COMCAT_IsClassOfCategories
 544  */
 545 static HRESULT COMCAT_IsClassOfCategories(
 546     HKEY key,
 547     struct class_categories const* categories)
 548 {
 549     WCHAR impl_keyname[23] = { 'I', 'm', 'p', 'l', 'e', 'm', 'e', 'n',
 550                                't', 'e', 'd', ' ', 'C', 'a', 't', 'e',
 551                                'g', 'o', 'r', 'i', 'e', 's', 0 };
 552     WCHAR req_keyname[20] = { 'R', 'e', 'q', 'u', 'i', 'r', 'e', 'd',
 553                               ' ', 'C', 'a', 't', 'e', 'g', 'o', 'r',
 554                               'i', 'e', 's', 0 };
 555     HKEY subkey;
 556     HRESULT res;
 557     DWORD index;
 558     LPCWSTR string;
 559
 560     /* Check that every given category is implemented by class. */
 561     res = RegOpenKeyExW(key, impl_keyname, 0, KEY_READ, &subkey);
 562     if (res != ERROR_SUCCESS) return S_FALSE;
 563     for (string = categories->impl_strings; *string; string += 39) {
 564         HKEY catkey;
 565         res = RegOpenKeyExW(subkey, string, 0, 0, &catkey);
 566         if (res != ERROR_SUCCESS) {
 567             RegCloseKey(subkey);
 568             return S_FALSE;
 569         }
 570         RegCloseKey(catkey);
 571     }
 572     RegCloseKey(subkey);
 573
 574     /* Check that all categories required by class are given. */
 575     res = RegOpenKeyExW(key, req_keyname, 0, KEY_READ, &subkey);
 576     if (res == ERROR_SUCCESS) {
 577         for (index = 0; ; ++index) {
 578             WCHAR keyname[39];
 579             DWORD size = 39;
 580
 581             res = RegEnumKeyExW(subkey, index, keyname, &size,
 582                                 NULL, NULL, NULL, NULL);
 583             if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
 584             if (size != 38) continue; /* bogus catid in registry */
 585             for (string = categories->req_strings; *string; string += 39)
 586                 if (!strcmpiW(string, keyname)) break;
 587             if (!*string) {
 588                 RegCloseKey(subkey);
 589                 return S_FALSE;
 590             }
 591         }
 592         RegCloseKey(subkey);
 593     }
 594
 595     return S_OK;
 596 }
 597
 598 /**********************************************************************
 599  * ClassesOfCategories IEnumCLSID (IEnumGUID) implementation
 600  *
 601  * This implementation is not thread-safe.  The manager itself is, but
 602  * I can't imagine a valid use of an enumerator in several threads.
 603  */
 604 typedef struct
 605 {
 606     IEnumGUIDVtbl *lpVtbl;
 607     DWORD ref;
 608     struct class_categories const *categories;
 609     HKEY  key;
 610     DWORD next_index;
 611 } CLSID_IEnumGUIDImpl;
 612
 613 static ULONG WINAPI COMCAT_CLSID_IEnumGUID_AddRef(LPENUMGUID iface)
 614 {
 615     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 616     TRACE("\n");
 617
 618     if (This == NULL) return E_POINTER;
 619
 620     return InterlockedIncrement(&This->ref);
 621 }
 622
 623 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_QueryInterface(
 624     LPENUMGUID iface,
 625     REFIID riid,
 626     LPVOID *ppvObj)
 627 {
 628     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 629     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
 630
 631     if (This == NULL || ppvObj == NULL) return E_POINTER;
 632
 633     if (IsEqualGUID(riid, &IID_IUnknown) ||
 634         IsEqualGUID(riid, &IID_IEnumGUID))
 635     {
 636         *ppvObj = (LPVOID)iface;
 637         COMCAT_CLSID_IEnumGUID_AddRef(iface);
 638         return S_OK;
 639     }
 640
 641     return E_NOINTERFACE;
 642 }
 643
 644 static ULONG WINAPI COMCAT_CLSID_IEnumGUID_Release(LPENUMGUID iface)
 645 {
 646     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 647     ULONG ref;
 648
 649     TRACE("\n");
 650
 651     if (This == NULL) return E_POINTER;
 652
 653     ref = InterlockedDecrement(&This->ref);
 654     if (ref == 0) {
 655         if (This->key) RegCloseKey(This->key);
 656         HeapFree(GetProcessHeap(), 0, (LPVOID)This->categories);
 657         HeapFree(GetProcessHeap(), 0, This);
 658         return 0;
 659     }
 660     return ref;
 661 }
 662
 663 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Next(
 664     LPENUMGUID iface,
 665     ULONG celt,
 666     GUID *rgelt,
 667     ULONG *pceltFetched)
 668 {
 669     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 670     ULONG fetched = 0;
 671
 672     TRACE("\n");
 673
 674     if (This == NULL || rgelt == NULL) return E_POINTER;
 675
 676     if (This->key) while (fetched < celt) {
 677         HRESULT res;
 678         WCHAR clsid[39];
 679         DWORD cName = 39;
 680         HKEY subkey;
 681
 682         res = RegEnumKeyExW(This->key, This->next_index, clsid, &cName,
 683                             NULL, NULL, NULL, NULL);
 684         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
 685         ++(This->next_index);
 686
 687         res = CLSIDFromString(clsid, rgelt);
 688         if (FAILED(res)) continue;
 689
 690         res = RegOpenKeyExW(This->key, clsid, 0, KEY_READ, &subkey);
 691         if (res != ERROR_SUCCESS) continue;
 692
 693         res = COMCAT_IsClassOfCategories(subkey, This->categories);
 694         RegCloseKey(subkey);
 695         if (res != S_OK) continue;
 696
 697         ++fetched;
 698         ++rgelt;
 699     }
 700
 701     if (pceltFetched) *pceltFetched = fetched;
 702     return fetched == celt ? S_OK : S_FALSE;
 703 }
 704
 705 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Skip(
 706     LPENUMGUID iface,
 707     ULONG celt)
 708 {
 709     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 710
 711     TRACE("\n");
 712
 713     if (This == NULL) return E_POINTER;
 714     This->next_index += celt;
 715     FIXME("Never returns S_FALSE\n");
 716     return S_OK;
 717 }
 718
 719 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Reset(LPENUMGUID iface)
 720 {
 721     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 722
 723     TRACE("\n");
 724
 725     if (This == NULL) return E_POINTER;
 726     This->next_index = 0;
 727     return S_OK;
 728 }
 729
 730 static HRESULT WINAPI COMCAT_CLSID_IEnumGUID_Clone(
 731     LPENUMGUID iface,
 732     IEnumGUID **ppenum)
 733 {
 734     CLSID_IEnumGUIDImpl *This = (CLSID_IEnumGUIDImpl *)iface;
 735     WCHAR keyname[6] = { 'C', 'L', 'S', 'I', 'D', 0 };
 736     CLSID_IEnumGUIDImpl *new_this;
 737     DWORD size;
 738
 739     TRACE("\n");
 740
 741     if (This == NULL || ppenum == NULL) return E_POINTER;
 742
 743     new_this = (CLSID_IEnumGUIDImpl *) HeapAlloc(
 744         GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLSID_IEnumGUIDImpl));
 745     if (new_this == NULL) return E_OUTOFMEMORY;
 746
 747     new_this->lpVtbl = This->lpVtbl;
 748     new_this->ref = 1;
 749     size = HeapSize(GetProcessHeap(), 0, (LPVOID)This->categories);
 750     new_this->categories = (struct class_categories *)
 751         HeapAlloc(GetProcessHeap(), 0, size);
 752     if (new_this->categories == NULL) {
 753         HeapFree(GetProcessHeap(), 0, new_this);
 754         return E_OUTOFMEMORY;
 755     }
 756     memcpy((LPVOID)new_this->categories, This->categories, size);
 757     /* FIXME: could we more efficiently use DuplicateHandle? */
 758     RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &new_this->key);
 759     new_this->next_index = This->next_index;
 760
 761     *ppenum = (LPENUMGUID)new_this;
 762     return S_OK;
 763 }
 764
 765 IEnumGUIDVtbl COMCAT_CLSID_IEnumGUID_Vtbl =
 766 {
 767     COMCAT_CLSID_IEnumGUID_QueryInterface,
 768     COMCAT_CLSID_IEnumGUID_AddRef,
 769     COMCAT_CLSID_IEnumGUID_Release,
 770     COMCAT_CLSID_IEnumGUID_Next,
 771     COMCAT_CLSID_IEnumGUID_Skip,
 772     COMCAT_CLSID_IEnumGUID_Reset,
 773     COMCAT_CLSID_IEnumGUID_Clone
 774 };
 775
 776 static LPENUMGUID COMCAT_CLSID_IEnumGUID_Construct(
 777     struct class_categories const* categories)
 778 {
 779     CLSID_IEnumGUIDImpl *This;
 780
 781     This = (CLSID_IEnumGUIDImpl *) HeapAlloc(
 782         GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CLSID_IEnumGUIDImpl));
 783     if (This) {
 784         WCHAR keyname[6] = { 'C', 'L', 'S', 'I', 'D', 0 };
 785
 786         This->lpVtbl = &COMCAT_CLSID_IEnumGUID_Vtbl;
 787         This->categories = categories;
 788         RegOpenKeyExW(HKEY_CLASSES_ROOT, keyname, 0, KEY_READ, &This->key);
 789     }
 790     return (LPENUMGUID)This;
 791 }
 792
 793 /**********************************************************************
 794  * CategoriesOfClass IEnumCATID (IEnumGUID) implementation
 795  *
 796  * This implementation is not thread-safe.  The manager itself is, but
 797  * I can't imagine a valid use of an enumerator in several threads.
 798  */
 799 typedef struct
 800 {
 801     IEnumGUIDVtbl *lpVtbl;
 802     DWORD ref;
 803     WCHAR keyname[68];
 804     HKEY  key;
 805     DWORD next_index;
 806 } CATID_IEnumGUIDImpl;
 807
 808 static ULONG WINAPI COMCAT_CATID_IEnumGUID_AddRef(LPENUMGUID iface)
 809 {
 810     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 811     TRACE("\n");
 812
 813     if (This == NULL) return E_POINTER;
 814
 815     return InterlockedIncrement(&This->ref);
 816 }
 817
 818 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_QueryInterface(
 819     LPENUMGUID iface,
 820     REFIID riid,
 821     LPVOID *ppvObj)
 822 {
 823     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 824     TRACE("\n\tIID:\t%s\n",debugstr_guid(riid));
 825
 826     if (This == NULL || ppvObj == NULL) return E_POINTER;
 827
 828     if (IsEqualGUID(riid, &IID_IUnknown) ||
 829         IsEqualGUID(riid, &IID_IEnumGUID))
 830     {
 831         *ppvObj = (LPVOID)iface;
 832         COMCAT_CATID_IEnumGUID_AddRef(iface);
 833         return S_OK;
 834     }
 835
 836     return E_NOINTERFACE;
 837 }
 838
 839 static ULONG WINAPI COMCAT_CATID_IEnumGUID_Release(LPENUMGUID iface)
 840 {
 841     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 842     ULONG ref;
 843
 844     TRACE("\n");
 845
 846     if (This == NULL) return E_POINTER;
 847
 848     ref = InterlockedDecrement(&This->ref);
 849     if (ref == 0) {
 850         if (This->key) RegCloseKey(This->key);
 851         HeapFree(GetProcessHeap(), 0, This);
 852         return 0;
 853     }
 854     return ref;
 855 }
 856
 857 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Next(
 858     LPENUMGUID iface,
 859     ULONG celt,
 860     GUID *rgelt,
 861     ULONG *pceltFetched)
 862 {
 863     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 864     ULONG fetched = 0;
 865
 866     TRACE("\n");
 867
 868     if (This == NULL || rgelt == NULL) return E_POINTER;
 869
 870     if (This->key) while (fetched < celt) {
 871         HRESULT res;
 872         WCHAR catid[39];
 873         DWORD cName = 39;
 874
 875         res = RegEnumKeyExW(This->key, This->next_index, catid, &cName,
 876                             NULL, NULL, NULL, NULL);
 877         if (res != ERROR_SUCCESS && res != ERROR_MORE_DATA) break;
 878         ++(This->next_index);
 879
 880         res = CLSIDFromString(catid, rgelt);
 881         if (FAILED(res)) continue;
 882
 883         ++fetched;
 884         ++rgelt;
 885     }
 886
 887     if (pceltFetched) *pceltFetched = fetched;
 888     return fetched == celt ? S_OK : S_FALSE;
 889 }
 890
 891 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Skip(
 892     LPENUMGUID iface,
 893     ULONG celt)
 894 {
 895     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 896
 897     TRACE("\n");
 898
 899     if (This == NULL) return E_POINTER;
 900     This->next_index += celt;
 901     FIXME("Never returns S_FALSE\n");
 902     return S_OK;
 903 }
 904
 905 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Reset(LPENUMGUID iface)
 906 {
 907     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 908
 909     TRACE("\n");
 910
 911     if (This == NULL) return E_POINTER;
 912     This->next_index = 0;
 913     return S_OK;
 914 }
 915
 916 static HRESULT WINAPI COMCAT_CATID_IEnumGUID_Clone(
 917     LPENUMGUID iface,
 918     IEnumGUID **ppenum)
 919 {
 920     CATID_IEnumGUIDImpl *This = (CATID_IEnumGUIDImpl *)iface;
 921     CATID_IEnumGUIDImpl *new_this;
 922
 923     TRACE("\n");
 924
 925     if (This == NULL || ppenum == NULL) return E_POINTER;
 926
 927     new_this = (CATID_IEnumGUIDImpl *) HeapAlloc(
 928         GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CATID_IEnumGUIDImpl));
 929     if (new_this == NULL) return E_OUTOFMEMORY;
 930
 931     new_this->lpVtbl = This->lpVtbl;
 932     new_this->ref = 1;
 933     lstrcpyW(new_this->keyname, This->keyname);
 934     /* FIXME: could we more efficiently use DuplicateHandle? */
 935     RegOpenKeyExW(HKEY_CLASSES_ROOT, new_this->keyname, 0, KEY_READ, &new_this->key);
 936     new_this->next_index = This->next_index;
 937
 938     *ppenum = (LPENUMGUID)new_this;
 939     return S_OK;
 940 }
 941
 942 IEnumGUIDVtbl COMCAT_CATID_IEnumGUID_Vtbl =
 943 {
 944     COMCAT_CATID_IEnumGUID_QueryInterface,
 945     COMCAT_CATID_IEnumGUID_AddRef,
 946     COMCAT_CATID_IEnumGUID_Release,
 947     COMCAT_CATID_IEnumGUID_Next,
 948     COMCAT_CATID_IEnumGUID_Skip,
 949     COMCAT_CATID_IEnumGUID_Reset,
 950     COMCAT_CATID_IEnumGUID_Clone
 951 };
 952
 953 static LPENUMGUID COMCAT_CATID_IEnumGUID_Construct(
 954     REFCLSID rclsid, LPCWSTR postfix)
 955 {
 956     CATID_IEnumGUIDImpl *This;
 957
 958     This = (CATID_IEnumGUIDImpl *) HeapAlloc(
 959         GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(CATID_IEnumGUIDImpl));
 960     if (This) {
 961         WCHAR prefix[6] = { 'C', 'L', 'S', 'I', 'D', '\\' };
 962
 963         This->lpVtbl = &COMCAT_CATID_IEnumGUID_Vtbl;
 964         memcpy(This->keyname, prefix, sizeof(prefix));
 965         StringFromGUID2(rclsid, This->keyname + 6, 39);
 966         lstrcpyW(This->keyname + 44, postfix);
 967         RegOpenKeyExW(HKEY_CLASSES_ROOT, This->keyname, 0, KEY_READ, &This->key);
 968     }
 969     return (LPENUMGUID)This;
 970 }