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