dll/win32/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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include <precomp.h>
  20
  21 /**************************************************************
  22  * ATLRegistrar implementation
  23  */
  24
  25 static const struct {
  26     WCHAR name[22];
  27     HKEY  key;
  28 } root_keys[] = {
  29     {{'H','K','E','Y','_','C','L','A','S','S','E','S','_','R','O','O','T',0},
  30                     HKEY_CLASSES_ROOT},
  31     {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','U','S','E','R',0},
  32                     HKEY_CURRENT_USER},
  33     {{'H','K','E','Y','_','L','O','C','A','L','_','M','A','C','H','I','N','E',0},
  34                     HKEY_LOCAL_MACHINE},
  35     {{'H','K','E','Y','_','U','S','E','R','S',0},
  36                     HKEY_USERS},
  37     {{'H','K','E','Y','_','P','E','R','F','O','R','M','A','N','C','E','_','D','A','T','A',0},
  38                     HKEY_PERFORMANCE_DATA},
  39     {{'H','K','E','Y','_','D','Y','N','_','D','A','T','A',0},
  40                     HKEY_DYN_DATA},
  41     {{'H','K','E','Y','_','C','U','R','R','E','N','T','_','C','O','N','F','I','G',0},
  42                     HKEY_CURRENT_CONFIG},
  43     {{'H','K','C','R',0}, HKEY_CLASSES_ROOT},
  44     {{'H','K','C','U',0}, HKEY_CURRENT_USER},
  45     {{'H','K','L','M',0}, HKEY_LOCAL_MACHINE},
  46     {{'H','K','U',0},     HKEY_USERS},
  47     {{'H','K','P','D',0}, HKEY_PERFORMANCE_DATA},
  48     {{'H','K','D','D',0}, HKEY_DYN_DATA},
  49     {{'H','K','C','C',0}, HKEY_CURRENT_CONFIG}
  50 };
  51
  52 typedef struct rep_list_str {
  53     LPOLESTR key;
  54     LPOLESTR item;
  55     int key_len;
  56     struct rep_list_str *next;
  57 } rep_list;
  58
  59 typedef struct {
  60     IRegistrar IRegistrar_iface;
  61     LONG ref;
  62     rep_list *rep;
  63 } Registrar;
  64
  65 typedef struct {
  66     LPOLESTR str;
  67     DWORD alloc;
  68     DWORD len;
  69 } strbuf;
  70
  71 static inline Registrar *impl_from_IRegistrar(IRegistrar *iface)
  72 {
  73     return CONTAINING_RECORD(iface, Registrar, IRegistrar_iface);
  74 }
  75
  76 static void strbuf_init(strbuf *buf)
  77 {
  78     buf->str = HeapAlloc(GetProcessHeap(), 0, 128*sizeof(WCHAR));
  79     buf->alloc = 128;
  80     buf->len = 0;
  81 }
  82
  83 static void strbuf_write(LPCOLESTR str, strbuf *buf, int len)
  84 {
  85     if(len == -1)
  86         len = lstrlenW(str);
  87     if(buf->len+len+1 >= buf->alloc) {
  88         buf->alloc = (buf->len+len)<<1;
  89         buf->str = HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc*sizeof(WCHAR));
  90     }
  91     memcpy(buf->str+buf->len, str, len*sizeof(OLECHAR));
  92     buf->len += len;
  93     buf->str[buf->len] = '\0';
  94 }
  95
  96 static HRESULT get_word(LPCOLESTR *str, strbuf *buf)
  97 {
  98     LPCOLESTR iter, iter2 = *str;
  99
 100     buf->len = 0;
 101     buf->str[0] = '\0';
 102
 103     while(isspaceW(*iter2))
 104         iter2++;
 105     iter = iter2;
 106     if(!*iter) {
 107         *str = iter;
 108         return S_OK;
 109     }
 110
 111     if(*iter == '}' || *iter == '=') {
 112         strbuf_write(iter++, buf, 1);
 113     }else if(*iter == '\'') {
 114         iter2 = ++iter;
 115         iter = strchrW(iter, '\'');
 116         if(!iter) {
 117             WARN("Unexpected end of script\n");
 118             *str = iter;
 119             return DISP_E_EXCEPTION;
 120         }
 121         strbuf_write(iter2, buf, iter-iter2);
 122         iter++;
 123     }else {
 124         while(*iter && !isspaceW(*iter))
 125             iter++;
 126         strbuf_write(iter2, buf, iter-iter2);
 127     }
 128
 129     while(isspaceW(*iter))
 130         iter++;
 131     *str = iter;
 132     return S_OK;
 133 }
 134
 135 static HRESULT do_preprocess(const Registrar *This, LPCOLESTR data, strbuf *buf)
 136 {
 137     LPCOLESTR iter, iter2 = data;
 138     rep_list *rep_iter;
 139     static const WCHAR wstr[] = {'%',0};
 140
 141     iter = strchrW(data, '%');
 142     while(iter) {
 143         strbuf_write(iter2, buf, iter-iter2);
 144
 145         iter2 = ++iter;
 146         if(!*iter2)
 147             return DISP_E_EXCEPTION;
 148         iter = strchrW(iter2, '%');
 149         if(!iter)
 150             return DISP_E_EXCEPTION;
 151
 152         if(iter == iter2) {
 153             strbuf_write(wstr, buf, 1);
 154         }else {
 155             for(rep_iter = This->rep; rep_iter; rep_iter = rep_iter->next) {
 156                 if(rep_iter->key_len == iter-iter2
 157                         && !memicmpW(iter2, rep_iter->key, rep_iter->key_len))
 158                     break;
 159             }
 160             if(!rep_iter) {
 161                 WARN("Could not find replacement: %s\n", debugstr_wn(iter2, iter-iter2));
 162                 return DISP_E_EXCEPTION;
 163             }
 164
 165             strbuf_write(rep_iter->item, buf, -1);
 166         }
 167
 168         iter2 = ++iter;
 169         iter = strchrW(iter, '%');
 170     }
 171
 172     strbuf_write(iter2, buf, -1);
 173     TRACE("%s\n", debugstr_w(buf->str));
 174
 175     return S_OK;
 176 }
 177
 178 static HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register)
 179 {
 180     LPCOLESTR iter = *pstr;
 181     HRESULT hres;
 182     LONG lres;
 183     HKEY hkey = 0;
 184     strbuf name;
 185
 186     enum {
 187         NORMAL,
 188         NO_REMOVE,
 189         IS_VAL,
 190         FORCE_REMOVE,
 191         DO_DELETE
 192     } key_type = NORMAL;
 193
 194     static const WCHAR wstrNoRemove[] = {'N','o','R','e','m','o','v','e',0};
 195     static const WCHAR wstrForceRemove[] = {'F','o','r','c','e','R','e','m','o','v','e',0};
 196     static const WCHAR wstrDelete[] = {'D','e','l','e','t','e',0};
 197     static const WCHAR wstrval[] = {'v','a','l',0};
 198
 199     iter = *pstr;
 200     hres = get_word(&iter, buf);
 201     if(FAILED(hres))
 202         return hres;
 203     strbuf_init(&name);
 204
 205     while(buf->str[1] || buf->str[0] != '}') {
 206         key_type = NORMAL;
 207         if(!lstrcmpiW(buf->str, wstrNoRemove))
 208             key_type = NO_REMOVE;
 209         else if(!lstrcmpiW(buf->str, wstrForceRemove))
 210             key_type = FORCE_REMOVE;
 211         else if(!lstrcmpiW(buf->str, wstrval))
 212             key_type = IS_VAL;
 213         else if(!lstrcmpiW(buf->str, wstrDelete))
 214             key_type = DO_DELETE;
 215
 216         if(key_type != NORMAL) {
 217             hres = get_word(&iter, buf);
 218             if(FAILED(hres))
 219                 break;
 220         }
 221         TRACE("name = %s\n", debugstr_w(buf->str));
 222
 223         if(do_register) {
 224             if(key_type == IS_VAL) {
 225                 hkey = parent_key;
 226                 strbuf_write(buf->str, &name, -1);
 227             }else if(key_type == DO_DELETE) {
 228                 TRACE("Deleting %s\n", debugstr_w(buf->str));
 229                 RegDeleteTreeW(parent_key, buf->str);
 230             }else {
 231                 if(key_type == FORCE_REMOVE)
 232                     RegDeleteTreeW(parent_key, buf->str);
 233                 lres = RegCreateKeyW(parent_key, buf->str, &hkey);
 234                 if(lres != ERROR_SUCCESS) {
 235                     WARN("Could not create(open) key: %08x\n", lres);
 236                     hres = HRESULT_FROM_WIN32(lres);
 237                     break;
 238                 }
 239             }
 240         }else if(key_type != IS_VAL && key_type != DO_DELETE) {
 241             strbuf_write(buf->str, &name, -1);
 242             lres = RegOpenKeyW(parent_key, buf->str, &hkey);
 243               if(lres != ERROR_SUCCESS)
 244                 WARN("Could not open key %s: %08x\n", debugstr_w(name.str), lres);
 245         }
 246
 247         if(key_type != DO_DELETE && *iter == '=') {
 248             iter++;
 249             hres = get_word(&iter, buf);
 250             if(FAILED(hres))
 251                 break;
 252             if(buf->len != 1) {
 253                 WARN("Wrong registry type: %s\n", debugstr_w(buf->str));
 254                 hres = DISP_E_EXCEPTION;
 255                 break;
 256             }
 257             if(do_register) {
 258                 switch(buf->str[0]) {
 259                 case 's':
 260                     hres = get_word(&iter, buf);
 261                     if(FAILED(hres))
 262                         break;
 263                     lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_SZ, (PBYTE)buf->str,
 264                             (lstrlenW(buf->str)+1)*sizeof(WCHAR));
 265                     if(lres != ERROR_SUCCESS) {
 266                         WARN("Could set value of key: %08x\n", lres);
 267                         hres = HRESULT_FROM_WIN32(lres);
 268                         break;
 269                     }
 270                     break;
 271                 case 'd': {
 272                     DWORD dw;
 273                     hres = get_word(&iter, buf);
 274                     if(FAILED(hres))
 275                         break;
 276                     dw = atoiW(buf->str);
 277                     lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_DWORD,
 278                             (PBYTE)&dw, sizeof(dw));
 279                     if(lres != ERROR_SUCCESS) {
 280                         WARN("Could set value of key: %08x\n", lres);
 281                         hres = HRESULT_FROM_WIN32(lres);
 282                         break;
 283                     }
 284                     break;
 285                 }
 286                 case 'b': {
 287                     BYTE *bytes;
 288                     DWORD count;
 289                     DWORD i;
 290                     hres = get_word(&iter, buf);
 291                     if(FAILED(hres))
 292                         break;
 293                     count = (lstrlenW(buf->str) + 1) / 2;
 294                     bytes = HeapAlloc(GetProcessHeap(), 0, count);
 295                     if(bytes == NULL) {
 296                         hres = E_OUTOFMEMORY;
 297                         break;
 298                     }
 299                     for(i = 0; i < count && buf->str[2*i]; i++) {
 300                         WCHAR digits[3];
 301                         if(!isxdigitW(buf->str[2*i]) || !isxdigitW(buf->str[2*i + 1])) {
 302                             hres = E_FAIL;
 303                             break;
 304                         }
 305                         digits[0] = buf->str[2*i];
 306                         digits[1] = buf->str[2*i + 1];
 307                         digits[2] = 0;
 308                         bytes[i] = (BYTE) strtoulW(digits, NULL, 16);
 309                     }
 310                     if(SUCCEEDED(hres)) {
 311                         lres = RegSetValueExW(hkey, name.len ? name.str :  NULL, 0, REG_BINARY,
 312                             bytes, count);
 313                         if(lres != ERROR_SUCCESS) {
 314                             WARN("Could not set value of key: 0x%08x\n", lres);
 315                             hres = HRESULT_FROM_WIN32(lres);
 316                         }
 317                     }
 318                     HeapFree(GetProcessHeap(), 0, bytes);
 319                     break;
 320                 }
 321                 default:
 322                     WARN("Wrong resource type: %s\n", debugstr_w(buf->str));
 323                     hres = DISP_E_EXCEPTION;
 324                 };
 325                 if(FAILED(hres))
 326                     break;
 327             }else {
 328                 if(*iter == '-')
 329                     iter++;
 330                 hres = get_word(&iter, buf);
 331                 if(FAILED(hres))
 332                     break;
 333             }
 334         }else if(key_type == IS_VAL) {
 335             WARN("value not set!\n");
 336             hres = DISP_E_EXCEPTION;
 337             break;
 338         }
 339
 340         if(key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && isspaceW(iter[1])) {
 341             hres = get_word(&iter, buf);
 342             if(FAILED(hres))
 343                 break;
 344             hres = do_process_key(&iter, hkey, buf, do_register);
 345             if(FAILED(hres))
 346                 break;
 347         }
 348
 349         TRACE("%x %x\n", do_register, key_type);
 350         if(!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) {
 351             TRACE("Deleting %s\n", debugstr_w(name.str));
 352             RegDeleteKeyW(parent_key, name.str);
 353         }
 354
 355         if(hkey && key_type != IS_VAL)
 356             RegCloseKey(hkey);
 357         hkey = 0;
 358         name.len = 0;
 359
 360         hres = get_word(&iter, buf);
 361         if(FAILED(hres))
 362             break;
 363     }
 364
 365     HeapFree(GetProcessHeap(), 0, name.str);
 366     if(hkey && key_type != IS_VAL)
 367         RegCloseKey(hkey);
 368     *pstr = iter;
 369     return hres;
 370 }
 371
 372 static HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register)
 373 {
 374     LPCOLESTR iter = data;
 375     strbuf buf;
 376     HRESULT hres = S_OK;
 377     unsigned int i;
 378
 379     strbuf_init(&buf);
 380     hres = get_word(&iter, &buf);
 381     if(FAILED(hres))
 382         return hres;
 383
 384     while(*iter) {
 385         if(!buf.len) {
 386             WARN("ward.len == 0, failed\n");
 387             hres = DISP_E_EXCEPTION;
 388             break;
 389         }
 390         for(i=0; i<sizeof(root_keys)/sizeof(root_keys[0]); i++) {
 391             if(!lstrcmpiW(buf.str, root_keys[i].name))
 392                 break;
 393         }
 394         if(i == sizeof(root_keys)/sizeof(root_keys[0])) {
 395             WARN("Wrong root key name: %s\n", debugstr_w(buf.str));
 396             hres = DISP_E_EXCEPTION;
 397             break;
 398         }
 399         hres = get_word(&iter, &buf);
 400         if(FAILED(hres))
 401             break;
 402         if(buf.str[1] || buf.str[0] != '{') {
 403             WARN("Failed, expected '{', got %s\n", debugstr_w(buf.str));
 404             hres = DISP_E_EXCEPTION;
 405             break;
 406         }
 407         hres = do_process_key(&iter, root_keys[i].key, &buf, do_register);
 408         if(FAILED(hres)) {
 409             WARN("Processing key failed: %08x\n", hres);
 410             break;
 411         }
 412         hres = get_word(&iter, &buf);
 413         if(FAILED(hres))
 414             break;
 415     }
 416     HeapFree(GetProcessHeap(), 0, buf.str);
 417     return hres;
 418 }
 419
 420 static HRESULT string_register(Registrar *This, LPCOLESTR data, BOOL do_register)
 421 {
 422     strbuf buf;
 423     HRESULT hres;
 424
 425     TRACE("(%p %s %x)\n", This, debugstr_w(data), do_register);
 426
 427     strbuf_init(&buf);
 428     hres = do_preprocess(This, data, &buf);
 429     if(FAILED(hres)) {
 430         WARN("preprocessing failed!\n");
 431         HeapFree(GetProcessHeap(), 0, buf.str);
 432         return hres;
 433     }
 434
 435     hres = do_process_root_key(buf.str, do_register);
 436     if(FAILED(hres) && do_register)
 437         do_process_root_key(buf.str, FALSE);
 438
 439     HeapFree(GetProcessHeap(), 0, buf.str);
 440     return hres;
 441 }
 442
 443 static HRESULT resource_register(Registrar *This, LPCOLESTR resFileName,
 444                         LPCOLESTR szID, LPCOLESTR szType, BOOL do_register)
 445 {
 446     HINSTANCE hins;
 447     HRSRC src;
 448     LPSTR regstra;
 449     LPWSTR regstrw;
 450     DWORD len, reslen;
 451     HRESULT hres;
 452
 453     hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE);
 454     if(hins) {
 455         src = FindResourceW(hins, szID, szType);
 456         if(src) {
 457             regstra = LoadResource(hins, src);
 458             reslen = SizeofResource(hins, src);
 459             if(regstra) {
 460                 len = MultiByteToWideChar(CP_ACP, 0, regstra, reslen, NULL, 0)+1;
 461                 regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
 462                 MultiByteToWideChar(CP_ACP, 0, regstra, reslen, regstrw, len);
 463                 regstrw[len-1] = '\0';
 464
 465                 hres = string_register(This, regstrw, do_register);
 466
 467                 HeapFree(GetProcessHeap(), 0, regstrw);
 468             }else {
 469                 WARN("could not load resource\n");
 470                 hres = HRESULT_FROM_WIN32(GetLastError());
 471             }
 472         }else {
 473             WARN("Could not find source\n");
 474             hres = HRESULT_FROM_WIN32(GetLastError());
 475         }
 476         FreeLibrary(hins);
 477     }else {
 478         WARN("Could not load resource file\n");
 479         hres = HRESULT_FROM_WIN32(GetLastError());
 480     }
 481
 482     return hres;
 483 }
 484
 485 static HRESULT file_register(Registrar *This, LPCOLESTR fileName, BOOL do_register)
 486 {
 487     HANDLE file;
 488     DWORD filelen, len;
 489     LPWSTR regstrw;
 490     LPSTR regstra;
 491     HRESULT hres;
 492
 493     file = CreateFileW(fileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL);
 494     if(file != INVALID_HANDLE_VALUE) {
 495         filelen = GetFileSize(file, NULL);
 496         regstra = HeapAlloc(GetProcessHeap(), 0, filelen);
 497         if(ReadFile(file, regstra, filelen, NULL, NULL)) {
 498             len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0)+1;
 499             regstrw = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len*sizeof(WCHAR));
 500             MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len);
 501             regstrw[len-1] = '\0';
 502
 503             hres = string_register(This, regstrw, do_register);
 504
 505             HeapFree(GetProcessHeap(), 0, regstrw);
 506         }else {
 507             WARN("Failed to read file %s\n", debugstr_w(fileName));
 508             hres = HRESULT_FROM_WIN32(GetLastError());
 509         }
 510         HeapFree(GetProcessHeap(), 0, regstra);
 511         CloseHandle(file);
 512     }else {
 513         WARN("Could not open file %s\n", debugstr_w(fileName));
 514         hres = HRESULT_FROM_WIN32(GetLastError());
 515     }
 516
 517     return hres;
 518 }
 519
 520 static HRESULT WINAPI Registrar_QueryInterface(IRegistrar *iface, REFIID riid, void **ppvObject)
 521 {
 522     TRACE("(%p)->(%s %p\n", iface, debugstr_guid(riid), ppvObject);
 523
 524     if(IsEqualGUID(&IID_IUnknown, riid)
 525        || IsEqualGUID(&IID_IRegistrar, riid)
 526        || IsEqualGUID(&IID_IRegistrarBase, riid)) {
 527         IRegistrar_AddRef(iface);
 528         *ppvObject = iface;
 529         return S_OK;
 530     }
 531     return E_NOINTERFACE;
 532 }
 533
 534 static ULONG WINAPI Registrar_AddRef(IRegistrar *iface)
 535 {
 536     Registrar *This = impl_from_IRegistrar(iface);
 537     ULONG ref = InterlockedIncrement(&This->ref);
 538     TRACE("(%p) ->%d\n", This, ref);
 539     return ref;
 540 }
 541
 542 static ULONG WINAPI Registrar_Release(IRegistrar *iface)
 543 {
 544     Registrar *This = impl_from_IRegistrar(iface);
 545     ULONG ref = InterlockedDecrement(&This->ref);
 546
 547     TRACE("(%p) ->%d\n", This, ref);
 548     if(!ref) {
 549         IRegistrar_ClearReplacements(iface);
 550         HeapFree(GetProcessHeap(), 0, This);
 551     }
 552     return ref;
 553 }
 554
 555 static HRESULT WINAPI Registrar_AddReplacement(IRegistrar *iface, LPCOLESTR Key, LPCOLESTR item)
 556 {
 557     Registrar *This = impl_from_IRegistrar(iface);
 558     int len;
 559     rep_list *new_rep;
 560
 561     TRACE("(%p)->(%s %s)\n", This, debugstr_w(Key), debugstr_w(item));
 562
 563     new_rep = HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list));
 564
 565     new_rep->key_len  = lstrlenW(Key);
 566     new_rep->key = HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR));
 567     memcpy(new_rep->key, Key, (new_rep->key_len+1)*sizeof(OLECHAR));
 568
 569     len = lstrlenW(item)+1;
 570     new_rep->item = HeapAlloc(GetProcessHeap(), 0, len*sizeof(OLECHAR));
 571     memcpy(new_rep->item, item, len*sizeof(OLECHAR));
 572
 573     new_rep->next = This->rep;
 574     This->rep = new_rep;
 575
 576     return S_OK;
 577 }
 578
 579 static HRESULT WINAPI Registrar_ClearReplacements(IRegistrar *iface)
 580 {
 581     Registrar *This = impl_from_IRegistrar(iface);
 582     rep_list *iter, *iter2;
 583
 584     TRACE("(%p)\n", This);
 585
 586     if(!This->rep)
 587         return S_OK;
 588
 589     iter = This->rep;
 590     while(iter) {
 591         iter2 = iter->next;
 592         HeapFree(GetProcessHeap(), 0, iter->key);
 593         HeapFree(GetProcessHeap(), 0, iter->item);
 594         HeapFree(GetProcessHeap(), 0, iter);
 595         iter = iter2;
 596     }
 597
 598     This->rep = NULL;
 599     return S_OK;
 600 }
 601
 602 static HRESULT WINAPI Registrar_ResourceRegisterSz(IRegistrar* iface, LPCOLESTR resFileName,
 603                 LPCOLESTR szID, LPCOLESTR szType)
 604 {
 605     Registrar *This = impl_from_IRegistrar(iface);
 606     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
 607     return resource_register(This, resFileName, szID, szType, TRUE);
 608 }
 609
 610 static HRESULT WINAPI Registrar_ResourceUnregisterSz(IRegistrar* iface, LPCOLESTR resFileName,
 611                 LPCOLESTR szID, LPCOLESTR szType)
 612 {
 613     Registrar *This = impl_from_IRegistrar(iface);
 614     TRACE("(%p)->(%s %s %s)\n", This, debugstr_w(resFileName), debugstr_w(szID), debugstr_w(szType));
 615     return resource_register(This, resFileName, szID, szType, FALSE);
 616 }
 617
 618 static HRESULT WINAPI Registrar_FileRegister(IRegistrar* iface, LPCOLESTR fileName)
 619 {
 620     Registrar *This = impl_from_IRegistrar(iface);
 621     TRACE("(%p)->(%s)\n", This, debugstr_w(fileName));
 622     return file_register(This, fileName, TRUE);
 623 }
 624
 625 static HRESULT WINAPI Registrar_FileUnregister(IRegistrar* iface, LPCOLESTR fileName)
 626 {
 627     Registrar *This = impl_from_IRegistrar(iface);
 628     FIXME("(%p)->(%s)\n", This, debugstr_w(fileName));
 629     return file_register(This, fileName, FALSE);
 630 }
 631
 632 static HRESULT WINAPI Registrar_StringRegister(IRegistrar* iface, LPCOLESTR data)
 633 {
 634     Registrar *This = impl_from_IRegistrar(iface);
 635     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
 636     return string_register(This, data, TRUE);
 637 }
 638
 639 static HRESULT WINAPI Registrar_StringUnregister(IRegistrar* iface, LPCOLESTR data)
 640 {
 641     Registrar *This = impl_from_IRegistrar(iface);
 642     TRACE("(%p)->(%s)\n", This, debugstr_w(data));
 643     return string_register(This, data, FALSE);
 644 }
 645
 646 static HRESULT WINAPI Registrar_ResourceRegister(IRegistrar* iface, LPCOLESTR resFileName,
 647                 UINT nID, LPCOLESTR szType)
 648 {
 649     Registrar *This = impl_from_IRegistrar(iface);
 650     TRACE("(%p)->(%s %d %s)\n", iface, debugstr_w(resFileName), nID, debugstr_w(szType));
 651     return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, TRUE);
 652 }
 653
 654 static HRESULT WINAPI Registrar_ResourceUnregister(IRegistrar* iface, LPCOLESTR resFileName,
 655                 UINT nID, LPCOLESTR szType)
 656 {
 657     Registrar *This = impl_from_IRegistrar(iface);
 658     TRACE("(%p)->(%s %d %s)\n", This, debugstr_w(resFileName), nID, debugstr_w(szType));
 659     return resource_register(This, resFileName, MAKEINTRESOURCEW(nID), szType, FALSE);
 660 }
 661
 662 static const IRegistrarVtbl RegistrarVtbl = {
 663     Registrar_QueryInterface,
 664     Registrar_AddRef,
 665     Registrar_Release,
 666     Registrar_AddReplacement,
 667     Registrar_ClearReplacements,
 668     Registrar_ResourceRegisterSz,
 669     Registrar_ResourceUnregisterSz,
 670     Registrar_FileRegister,
 671     Registrar_FileUnregister,
 672     Registrar_StringRegister,
 673     Registrar_StringUnregister,
 674     Registrar_ResourceRegister,
 675     Registrar_ResourceUnregister,
 676 };
 677
 678 /***********************************************************************
 679  *           AtlCreateRegistrar              [atl100.@]
 680  */
 681 HRESULT WINAPI AtlCreateRegistrar(IRegistrar **ret)
 682 {
 683     Registrar *registrar;
 684
 685     registrar = HeapAlloc(GetProcessHeap(), 0, sizeof(*registrar));
 686     if(!registrar)
 687         return E_OUTOFMEMORY;
 688
 689     registrar->IRegistrar_iface.lpVtbl = &RegistrarVtbl;
 690     registrar->ref = 1;
 691     registrar->rep = NULL;
 692
 693     *ret = &registrar->IRegistrar_iface;
 694     return S_OK;
 695 }
 696
 697 /***********************************************************************
 698  *           AtlUpdateRegistryFromResourceD         [atl100.@]
 699  */
 700 HRESULT WINAPI AtlUpdateRegistryFromResourceD(HINSTANCE inst, LPCOLESTR res,
 701         BOOL bRegister, struct _ATL_REGMAP_ENTRY *pMapEntries, IRegistrar *pReg)
 702 {
 703     const struct _ATL_REGMAP_ENTRY *iter;
 704     WCHAR module_name[MAX_PATH];
 705     IRegistrar *registrar;
 706     HRESULT hres;
 707
 708     static const WCHAR moduleW[] = {'M','O','D','U','L','E',0};
 709     static const WCHAR registryW[] = {'R','E','G','I','S','T','R','Y',0};
 710
 711     if(!GetModuleFileNameW(inst, module_name, MAX_PATH)) {
 712         FIXME("hinst %p: did not get module name\n", inst);
 713         return E_FAIL;
 714     }
 715
 716     TRACE("%p (%s), %s, %d, %p, %p\n", inst, debugstr_w(module_name),
 717         debugstr_w(res), bRegister, pMapEntries, pReg);
 718
 719     if(pReg) {
 720         registrar = pReg;
 721     }else {
 722         hres = AtlCreateRegistrar(&registrar);
 723         if(FAILED(hres))
 724             return hres;
 725     }
 726
 727     IRegistrar_AddReplacement(registrar, moduleW, module_name);
 728
 729     for (iter = pMapEntries; iter && iter->szKey; iter++)
 730         IRegistrar_AddReplacement(registrar, iter->szKey, iter->szData);
 731
 732     if(bRegister)
 733         hres = IRegistrar_ResourceRegisterSz(registrar, module_name, res, registryW);
 734     else
 735         hres = IRegistrar_ResourceUnregisterSz(registrar, module_name, res, registryW);
 736
 737     if(registrar != pReg)
 738         IRegistrar_Release(registrar);
 739     return hres;
 740 }