git.oblomov.eu Git - wine/blob - dlls/atl/registrar.c

   1 /*
   2  * Copyright 2005 Jacek Caban
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19
  20 #include <stdarg.h>
  21
  22 #define COBJMACROS
  23
  24 #include "windef.h"
  25 #include "winbase.h"
  26 #include "winuser.h"
  27 #include "winreg.h"
  28 #include "objbase.h"
  29 #include "oaidl.h"
  30 #include "shlwapi.h"
  31
  32 #define ATL_INITGUID
  33 #include "atliface.h"
  34
  35 #include "wine/debug.h"
  36 #include "wine/unicode.h"
  37
  38 WINE_DEFAULT_DEBUG_CHANNEL(atl);
  39
  40 /**************************************************************
  41  * ATLRegistrar implementation
  42  */
  43
  44 static struct {
  45     WCHAR name[22];
  46     HKEY  key;
  47 } root_keys[] = {
  48     {{'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0},
  49                     HKEY_CLASSES_ROOT},
  50     {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0},
  51                     HKEY_CURRENT_USER},
  52     {{'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0},
  53                     HKEY_LOCAL_MACHINE},
  54     {{'H','K','E','Y','_','U','S','E','R','S',0},
  55                     HKEY_USERS},
  56     {{'H','K','E','Y','_','P','E','R','F','O','R','M','A','N','C','E','_','D','A','T','A',0},
  57                     HKEY_PERFORMANCE_DATA},
  58     {{'H','K','E','Y','_','D','Y','N','_','D','A','T','A',0},
  59                     HKEY_DYN_DATA},
  60     {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0},
  61                     HKEY_CURRENT_CONFIG},
  62     {{'H','K','C','R',0}, HKEY_CLASSES_ROOT},
  63     {{'H','K','C','U',0}, HKEY_CURRENT_USER},
  64     {{'H','K','L','M',0}, HKEY_LOCAL_MACHINE},
  65     {{'H','K','U',0},     HKEY_USERS},
  66     {{'H','K','P','D',0}, HKEY_PERFORMANCE_DATA},
  67     {{'H','K','D','D',0}, HKEY_DYN_DATA},
  68     {{'H','K','C','C',0}, HKEY_CURRENT_CONFIG}
  69 };
  70
  71 typedef struct rep_list_str {
  72     LPOLESTR key;
  73     LPOLESTR item;
  74     int key_len;
  75     struct rep_list_str *next;
  76 } rep_list;
  77
  78 typedef struct {
  79     IRegistrarVtbl *lpVtbl;
  80     ULONG ref;
  81     rep_list *rep;
  82 } Registrar;
  83
  84 typedef struct {
  85     LPOLESTR str;
  86     DWORD alloc;
  87     DWORD len;
  88 } strbuf;
  89
  90 static void strbuf_init(strbuf *buf)
  91 {
  92     buf->str = HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR));
  93     buf->alloc = 128;
  94     buf->len = 0;
  95 }
  96
  97 static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
  98 {
  99     if(len == -1)
 100         len = lstrlenW(str);
 101     if(buf->len+len+1 >= buf->alloc) {
 102         buf->alloc = (buf->len+len)<<1;
 103         buf->str = HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc*sizeof(WCHAR));
 104     }
 105     memcpy(buf->str+buf->len, str, len*sizeof(OLECHAR));
 106     buf->len += len;
 107     buf->str[buf->len] = '\0';
 108 }
 109
 110 static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
 111 {
 112     LPCOLESTR iter, iter2 = *str;
 113
 114     buf->len = 0;
 115     buf->str[0] = '\0';
 116
 117     while(isspaceW(*iter2))
 118         iter2++;
 119     iter = iter2;
 120     if(!*iter) {
 121         *str = iter;
 122         return S_OK;
 123     }
 124
 125     if(*iter == '{' || *iter == '}' || *iter == '=') {
 126         strbuf_write(iter++, buf, 1);
 127     }else if(*iter == '\'') {
 128         iter2 = ++iter;
 129         iter = strchrW(iter, '\'');
 130         if(!iter) {
 131             WARN("Unexpected end of script\n");
 132             *str = iter;
 133             return DISP_E_EXCEPTION;
 134         }
 135         strbuf_write(iter2, buf, iter-iter2);
 136         iter++;
 137     }else {
 138         while(*iter && !isspaceW(*iter))
 139             iter++;
 140         strbuf_write(iter2, buf, iter-iter2);
 141     }
 142
 143     while(isspaceW(*iter))
 144         iter++;
 145     *str = iter;
 146     return S_OK;
 147 }
 148
 149 static HRESULT do_preprocess(Registrar *This, LPCOLESTR data, strbuf *buf)
 150 {
 151     LPCOLESTR iter, iter2 = data;
 152     rep_list *rep_iter;
 153     static const WCHAR wstr[] = {'%',0};
 154
 155     iter = strchrW(data, '%');
 156     while(iter) {
 157         strbuf_write(iter2, buf, iter-iter2);
 158
 159         iter2 = ++iter;
 160         if(!*iter2)
 161             return DISP_E_EXCEPTION;
 162         iter = strchrW(iter2, '%');
 163         if(!iter)
 164             return DISP_E_EXCEPTION;
 165
 166         if(iter == iter2) {
 167             strbuf_write(wstr, buf, 1);
 168         }else {
 169             for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) {
 170                 if(rep_iter->key_len == iter-iter2
 171                         && !memcmp(iter2, rep_iter->key, rep_iter->key_len*sizeof(OLECHAR)))
 172                     break;
 173             }
 174             if(!rep_iter)
 175                 return DISP_E_EXCEPTION;
 176
 177             strbuf_write(rep_iter->item, buf, -1);
 178         }
 179
 180         iter2 = ++iter;
 181         iter = strchrW(iter, '%');
 182     }
 183
 184     strbuf_write(iter2, buf, -1);
 185     TRACE("%s\n", debugstr_w(buf->str));
 186
 187     return S_OK;
 188 }
 189
 190 static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
 191 {
 192     LPCOLESTR iter = *pstr;
 193     BOOL no_remove = FALSE, is_val = FALSE, force_remove = FALSE, do_delete = FALSE;
 194     HRESULT hres;
 195     LONG lres;
 196     HKEY hkey = 0;
 197     strbuf name;
 198
 199     static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
 200     static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
 201     static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
 202     static const WCHAR wstrval[] = {'v','a','l',0};
 203
 204     iter = *pstr;
 205     hres = get_word(&iter, buf);
 206     if(FAILED(hres))
 207         return hres;
 208     strbuf_init(&name);
 209
 210     while(buf->str[1] || buf->str[0] != '}') {
 211         if(!lstrcmpW(buf->str, wstrNoRemove)) {
 212             no_remove = TRUE;
 213         }else if(!lstrcmpW(buf->str, wstrForceRemove)) {
 214             force_remove = TRUE;
 215         }else if(!lstrcmpW(buf->str, wstrval)) {
 216             is_val = TRUE;
 217         }else if(!lstrcmpW(buf->str, wstrDelete)) {
 218             do_delete = TRUE;
 219         }else {
 220             TRACE("name = %s\n", debugstr_w(buf->str));
 221             if(do_register) {
 222                 if(is_val) {
 223                     if(force_remove || no_remove || do_delete) {
 224                         WARN("Attribites for value!\n");
 225                         hres = DISP_E_EXCEPTION;
 226                         break;
 227                     }
 228                     hkey = parent_key;
 229                     strbuf_write(buf->str, &name, -1);
 230                 }else if(do_delete) {
 231                     TRACE("Deleting %s\n", debugstr_w(buf->str));
 232                     lres = SHDeleteKeyW(parent_key, buf->str);
 233                 }else {
 234                     if(force_remove)
 235                         SHDeleteKeyW(parent_key, buf->str);
 236                     lres = RegCreateKeyW(parent_key, buf->str, &hkey);
 237                     if(lres != ERROR_SUCCESS) {
 238                         WARN("Could not create(open) key: %08lx\n", lres);
 239                         hres = HRESULT_FROM_WIN32(lres);
 240                         break;
 241                     }
 242                 }
 243             }else if(!is_val && !do_delete) {
 244                 strbuf_write(buf->str, &name, -1);
 245                 lres = RegOpenKeyW(parent_key, buf->str, &hkey);
 246                 if(lres != ERROR_SUCCESS)
 247                     WARN("Could not open key %s: %08lx\n", debugstr_w(name.str), lres);
 248             }
 249             if(!do_delete && *iter == '=') {
 250                 iter++;
 251                 hres = get_word(&iter, buf);
 252                 if(FAILED(hres))
 253                     break;
 254                 if(buf->len != 1) {
 255                     WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
 256                     hres = DISP_E_EXCEPTION;
 257                     break;
 258                 }
 259                 if(do_register) {
 260                     switch(buf->str[0]) {
 261                     case 's':
 262                         hres = get_word(&iter, buf);
 263                         if(FAILED(hres))
 264                             break;
 265                         lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_SZ, (PBYTE)buf->str,
 266                                 (lstrlenW(buf->str)+1)*sizeof(WCHAR));
 267                         if(lres != ERROR_SUCCESS) {
 268                             WARN("Could set value of key: %08lx\n", lres);
 269                             hres = HRESULT_FROM_WIN32(lres);
 270                             break;
 271                         }
 272                         break;
 273                     case 'd': {
 274                         DWORD dw;
 275                         if(*iter == '0' && iter[1] == 'x') {
 276                             iter += 2;
 277                             dw = strtolW(iter, (WCHAR**)&iter, 16);
 278                         }else {
 279                             dw = strtolW(iter, (WCHAR**)&iter, 10);
 280                         }
 281                         lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_DWORD,
 282                                 (PBYTE)&dw, sizeof(dw));
 283                         if(lres != ERROR_SUCCESS) {
 284                             WARN("Could set value of key: %08lx\n", lres);
 285                             hres = HRESULT_FROM_WIN32(lres);
 286                             break;
 287                         }
 288                         break;
 289                     }
 290                     default:
 291                         WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
 292                         hres = DISP_E_EXCEPTION;
 293                     };
 294                     if(FAILED(hres))
 295                         break;
 296                 }else {
 297                     if(*iter == '-')
 298                         iter++;
 299                     hres = get_word(&iter, buf);
 300                     if(FAILED(hres))
 301                         break;
 302                 }
 303             }else if(is_val) {
 304                 WARN("value not set!\n");
 305                 hres = DISP_E_EXCEPTION;
 306                 break;
 307             }
 308             if(!is_val && !do_delete && *iter == '{') {
 309                 hres = get_word(&iter, buf);
 310                 if(FAILED(hres))
 311                     break;
 312                 hres = do_process_key(&iter, hkey, buf, do_register);
 313                 if(FAILED(hres))
 314                     break;
 315             }
 316             if(!do_register && !do_delete && !is_val && !no_remove) {
 317                 TRACE("Deleting %s\n", debugstr_w(name.str));
 318                 RegDeleteKeyW(parent_key, name.str);
 319             }
 320             if(hkey && !is_val)
 321                 RegCloseKey(hkey);
 322             hkey = 0;
 323             name.len = 0;
 324             no_remove = is_val = force_remove = do_delete = FALSE;
 325         }
 326         hres = get_word(&iter, buf);
 327         if(FAILED(hres))
 328             break;
 329     }
 330
 331     HeapFree(GetProcessHeap(), 0, name.str);
 332     if(hkey && !is_val)
 333         RegCloseKey(hkey);
 334     *pstr = iter;
 335     return hres;
 336 }
 337
 338 static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
 339 {
 340     LPCOLESTR iter = data;
 341     strbuf buf;
 342     HRESULT hres = S_OK;
 343     int i;
 344
 345     strbuf_init(&buf);
 346     hres = get_word(&iter, &buf);
 347     if(FAILED(hres))
 348         return hres;
 349
 350     while(*iter) {
 351         if(!buf.len) {
 352             WARN("ward.len == 0, failed\n");
 353             hres = DISP_E_EXCEPTION;
 354             break;
 355         }
 356         for(i=0; i<sizeof(root_keys)/sizeof(root_keys[0]); i++) {
 357             if(!lstrcmpW(buf.str, root_keys[i].name))
 358                 break;
 359         }
 360         if(i == sizeof(root_keys)/sizeof(root_keys[0])) {
 361             WARN("Wrong root key name: %s\n", debugstr_w(buf.str));
 362             hres = DISP_E_EXCEPTION;
 363             break;
 364         }
 365         hres = get_word(&iter, &buf);
 366         if(FAILED(hres))
 367             break;
 368         if(buf.str[1] || buf.str[0] != '{') {
 369             WARN("Failed, expected '{', got %s\n", debugstr_w(buf.str));
 370             hres = DISP_E_EXCEPTION;
 371             break;
 372         }
 373         hres = do_process_key(&iter, root_keys[i].key, &buf, do_register);
 374         if(FAILED(hres)) {
 375             WARN("Processing key failed: %08lx\n", hres);
 376             break;
 377         }
 378         hres = get_word(&iter, &buf);
 379         if(FAILED(hres))
 380             break;
 381     }
 382     HeapFree(GetProcessHeap(), 0, buf.str);
 383     return hres;
 384 }
 385
 386 static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
 387 {
 388     strbuf buf;
 389     HRESULT hres;
 390
 391     TRACE("(%p %s %x)\n", This, debugstr_w(data), do_register);
 392
 393     strbuf_init(&buf);
 394     hres = do_preprocess(This, data, &buf);
 395     if(FAILED(hres)) {
 396         WARN("preprocessing failed!\n");
 397         HeapFree(GetProcessHeap(), 0, buf.str);
 398         return hres;
 399     }
 400
 401     hres = do_process_root_key(buf.str, do_register);
 402     if(FAILED(hres) && do_register)
 403         do_process_root_key(buf.str, FALSE);
 404
 405     HeapFree(GetProcessHeap(), 0, buf.str);
 406     return hres;
 407 }
 408
 409 static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName,
 410                         UINT nID, LPCOLESTR szType, BOOL do_register)
 411 {
 412     HINSTANCE hins;
 413     HRSRC src;
 414     LPSTR regstra;
 415     LPWSTR regstrw;
 416     DWORD len, reslen;
 417     HRESULT hres;
 418
 419     hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
 420     if(hins) {
 421         src = FindResourceW(hins, (LPWSTR)nID, szType);
 422         if(src) {
 423             regstra = (LPSTR)LoadResource(hins, src);
 424             reslen = SizeofResource(hins, src);
 425             if(regstra) {
 426                 len = MultiByteToWideChar(CP_ACP, 0, regstra, reslen, NULL, 0)+1;
 427                 regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
 428                 MultiByteToWideChar(CP_ACP, 0, regstra, reslen, regstrw, -1);
 429                 regstrw[len-1] = '\0';
 430
 431                 hres = string_register(This, regstrw, do_register);
 432
 433                 HeapFree(GetProcessHeap(), 0, regstrw);
 434                 HeapFree(GetProcessHeap(), 0, regstra);
 435             }else {
 436                 WARN("could not load resource\n");
 437                 hres = HRESULT_FROM_WIN32(GetLastError());
 438             }
 439         }else {
 440             WARN("Could not find source\n");
 441             hres = HRESULT_FROM_WIN32(GetLastError());
 442         }
 443         FreeLibrary(hins);
 444     }else {
 445         WARN("Could not load resource file\n");
 446         hres = HRESULT_FROM_WIN32(GetLastError());
 447     }
 448
 449     return hres;
 450 }
 451
 452 static HRESULT WINAPI Registrar_QueryInterface(IRegistrar *iface, REFIID riid, void **ppvObject)
 453 {
 454     TRACE("(%p)->(%s %p\n", iface, debugstr_guid(riid), ppvObject);
 455
 456     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRegistrar, riid)) {
 457         IRegistrar_AddRef(iface);
 458         *ppvObject = iface;
 459         return S_OK;
 460     }
 461     return E_NOINTERFACE;
 462 }
 463
 464 static ULONG WINAPI Registrar_AddRef(IRegistrar *iface)
 465 {
 466     Registrar *This = (Registrar*)iface;
 467     ULONG ref = InterlockedIncrement(&This->ref);
 468     TRACE("(%p) ->%ld\n", This, ref);
 469     return ref;
 470 }
 471
 472 static ULONG WINAPI Registrar_Release(IRegistrar *iface)
 473 {
 474     Registrar *This = (Registrar*)iface;
 475     ULONG ref = InterlockedDecrement(&This->ref);
 476
 477     TRACE("(%p) ->%ld\n", This, ref);
 478     if(!ref) {
 479         IRegistrar_ClearReplacements(iface);
 480         HeapFree(GetProcessHeap(), 0, This);
 481     }
 482     return ref;
 483 }
 484
 485 static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
 486 {
 487     Registrar *This = (Registrar*)iface;
 488     int len;
 489     rep_list *new_rep;
 490
 491     TRACE("(%p)->(%s %s)\n", This, debugstr_w(Key), debugstr_w(item));
 492
 493     new_rep = HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list));
 494
 495     new_rep->key_len  = lstrlenW(Key);
 496     new_rep->key = HeapAlloc(GetProcessHeap(), 0, new_rep->key_len*sizeof(OLECHAR)+1);
 497     memcpy(new_rep->key, Key, (new_rep->key_len+1)*sizeof(OLECHAR));
 498
 499     len = lstrlenW(item)+1;
 500     new_rep->item = HeapAlloc(GetProcessHeap(), 0, len*sizeof(OLECHAR));
 501     memcpy(new_rep->item, item, len*sizeof(OLECHAR));
 502
 503     new_rep->next = This->rep;
 504     This->rep = new_rep;
 505
 506     return S_OK;
 507 }
 508
 509 static HRESULT WINAPI Registrar_ClearReplacements(IRegistrar *iface)
 510 {
 511     Registrar *This = (Registrar*)iface;
 512     rep_list *iter, *iter2;
 513
 514     TRACE("(%p)\n", This);
 515
 516     if(!This->rep)
 517         return S_OK;
 518
 519     iter = This->rep;
 520     while(iter) {
 521         iter2 = iter->next;
 522         HeapFree(GetProcessHeap(), 0, iter->key);
 523         HeapFree(GetProcessHeap(), 0, iter->item);
 524         HeapFree(GetProcessHeap(), 0, iter);
 525         iter = iter2;
 526     }
 527
 528     This->rep = NULL;
 529     return S_OK;
 530 }
 531
 532 static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar* iface, LPCOLESTR resFileName,
 533                 LPCOLESTR szID, LPCOLESTR szType)
 534 {
 535     Registrar *This = (Registrar*)iface;
 536     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
 537     return E_NOTIMPL;
 538 }
 539
 540 static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar* iface, LPCOLESTR resFileName,
 541                 LPCOLESTR szID, LPCOLESTR szType)
 542 {
 543     Registrar *This = (Registrar*)iface;
 544     FIXME("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
 545     return E_NOTIMPL;
 546 }
 547
 548 static HRESULT WINAPI Registrar_FileRegister(IRegistrar* iface, LPCOLESTR fileName)
 549 {
 550     Registrar *This = (Registrar*)iface;
 551     FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
 552     return E_NOTIMPL;
 553 }
 554
 555 static HRESULT WINAPI Registrar_FileUnregister(IRegistrar* iface, LPCOLESTR fileName)
 556 {
 557     Registrar *This = (Registrar*)iface;
 558     FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
 559     return E_NOTIMPL;
 560 }
 561
 562 static HRESULT WINAPI Registrar_StringRegister(IRegistrar* iface, LPCOLESTR data)
 563 {
 564     Registrar *This = (Registrar*)iface;
 565     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
 566     return string_register(This, data, TRUE);
 567 }
 568
 569 static HRESULT WINAPI Registrar_StringUnregister(IRegistrar* iface, LPCOLESTR data)
 570 {
 571     Registrar *This = (Registrar*)iface;
 572     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
 573     return string_register(This, data, FALSE);
 574 }
 575
 576 static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar* iface, LPCOLESTR resFileName,
 577                 UINT nID, LPCOLESTR szType)
 578 {
 579     Registrar *This = (Registrar*)iface;
 580     TRACE("(%p)->(%s %d %s)\n", iface, debugstr_w(resFileName), nID, debugstr_w(szType));
 581     return resource_register(This, resFileName, nID, szType, TRUE);
 582 }
 583
 584 static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar* iface, LPCOLESTR resFileName,
 585                 UINT nID, LPCOLESTR szType)
 586 {
 587     Registrar *This = (Registrar*)iface;
 588     TRACE("(%p)->(%s %d %s)\n", This, debugstr_w(resFileName), nID, debugstr_w(szType));
 589     return resource_register(This, resFileName, nID, szType, FALSE);
 590 }
 591
 592 static IRegistrarVtbl RegistrarVtbl = {
 593     Registrar_QueryInterface,
 594     Registrar_AddRef,
 595     Registrar_Release,
 596     Registrar_AddReplacement,
 597     Registrar_ClearReplacements,
 598     Registrar_ResourceRegisterSz,
 599     Registrar_ResourceUnregisterSz,
 600     Registrar_FileRegister,
 601     Registrar_FileUnregister,
 602     Registrar_StringRegister,
 603     Registrar_StringUnregister,
 604     Registrar_ResourceRegister,
 605     Registrar_ResourceUnregister,
 606 };
 607
 608
 609 /**************************************************************
 610  * ClassFactory implementation
 611  */
 612
 613 static HRESULT WINAPI RegistrarCF_QueryInterface(IClassFactory *iface, REFIID riid, void **ppvObject)
 614 {
 615     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
 616
 617     if(IsEqualGUID(&IID_IUnknown, riid) || IsEqualGUID(&IID_IRegistrar, riid)) {
 618         *ppvObject = iface;
 619         return S_OK;
 620     }
 621
 622     return E_NOINTERFACE;
 623 }
 624
 625 static ULONG WINAPI RegistrarCF_AddRef(IClassFactory *iface)
 626 {
 627     return 2;
 628 }
 629
 630 static ULONG WINAPI RegistrarCF_Release(IClassFactory *iface)
 631 {
 632     return 1;
 633 }
 634
 635 static HRESULT WINAPI RegistrarCF_CreateInstance(IClassFactory *iface, LPUNKNOWN pUnkOuter, REFIID riid, void **ppvObject)
 636 {
 637     Registrar *ret;
 638     TRACE("(%p)->(%s %p)\n", iface, debugstr_guid(riid), ppvObject);
 639
 640     if(!IsEqualGUID(&IID_IUnknown, riid) && !IsEqualGUID(&IID_IRegistrar, riid))
 641         return E_NOINTERFACE;
 642
 643     ret = HeapAlloc(GetProcessHeap(), 0, sizeof(Registrar));
 644     ret->lpVtbl = &RegistrarVtbl;
 645     ret->ref = 1;
 646     ret->rep = NULL;
 647     *ppvObject = ret;
 648
 649     return S_OK;
 650 }
 651
 652 static HRESULT WINAPI RegistrarCF_LockServer(IClassFactory *iface, BOOL lock)
 653 {
 654     FIXME("(%p)->(%x)\n", iface, lock);
 655     return S_OK;
 656 }
 657
 658 static const IClassFactoryVtbl IRegistrarCFVtbl = {
 659     RegistrarCF_QueryInterface,
 660     RegistrarCF_AddRef,
 661     RegistrarCF_Release,
 662     RegistrarCF_CreateInstance,
 663     RegistrarCF_LockServer
 664 };
 665
 666 static IClassFactory RegistrarCF = { &IRegistrarCFVtbl };
 667
 668 /**************************************************************
 669  * DllGetClassObject implementation
 670  */
 671 HRESULT WINAPI ATL_DllGetClassObject(REFCLSID clsid, REFIID riid, LPVOID *ppvObject)
 672 {
 673     TRACE("(%s %s %p)", debugstr_guid(clsid), debugstr_guid(riid), ppvObject);
 674
 675     if(IsEqualGUID(&CLSID_ATLRegistrar, clsid)) {
 676         *ppvObject = &RegistrarCF;
 677         return S_OK;
 678     }
 679
 680     FIXME("Not supported class %s\n", debugstr_guid(clsid));
 681     return CLASS_E_CLASSNOTAVAILABLE;
 682 }