ReactOS Development > Doxygen
statreg.h
Go to the documentation of this file.
00001 /* 00002 * ReactOS ATL 00003 * 00004 * Copyright 2005 Jacek Caban 00005 * Copyright 2009 Andrew Hill <ash77@reactos.org> 00006 * 00007 * This library is free software; you can redistribute it and/or 00008 * modify it under the terms of the GNU Lesser General Public 00009 * License as published by the Free Software Foundation; either 00010 * version 2.1 of the License, or (at your option) any later version. 00011 * 00012 * This library is distributed in the hope that it will be useful, 00013 * but WITHOUT ANY WARRANTY; without even the implied warranty of 00014 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 00015 * Lesser General Public License for more details. 00016 * 00017 * You should have received a copy of the GNU Lesser General Public 00018 * License along with this library; if not, write to the Free Software 00019 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 00020 */ 00021 00022 #pragma once 00023 00024 class IRegistrarBase : public IUnknown 00025 { 00026 public: 00027 virtual HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item) = 0; 00028 virtual HRESULT STDMETHODCALLTYPE ClearReplacements() = 0; 00029 }; 00030 00031 namespace ATL 00032 { 00033 00034 class CRegObject : public IRegistrarBase 00035 { 00036 public: 00037 typedef struct rep_list_str 00038 { 00039 LPOLESTR key; 00040 LPOLESTR item; 00041 int key_len; 00042 struct rep_list_str *next; 00043 } rep_list; 00044 00045 typedef struct 00046 { 00047 LPOLESTR str; 00048 DWORD alloc; 00049 DWORD len; 00050 } strbuf; 00051 00052 rep_list *m_rep; 00053 00054 public: 00055 CRegObject() 00056 { 00057 m_rep = NULL; 00058 } 00059 00060 ~CRegObject() 00061 { 00062 HRESULT hResult; 00063 00064 hResult = ClearReplacements(); 00065 ATLASSERT(SUCCEEDED(hResult)); 00066 } 00067 00068 HRESULT STDMETHODCALLTYPE QueryInterface(const IID & /* riid */, void ** /* ppvObject */ ) 00069 { 00070 ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function")); 00071 return E_NOTIMPL; 00072 } 00073 00074 ULONG STDMETHODCALLTYPE AddRef() 00075 { 00076 ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function")); 00077 return 1; 00078 } 00079 00080 ULONG STDMETHODCALLTYPE Release() 00081 { 00082 ATLASSERT(_T("statically linked in CRegObject is not a com object. Do not callthis function")); 00083 return 0; 00084 } 00085 00086 HRESULT STDMETHODCALLTYPE AddReplacement(LPCOLESTR key, LPCOLESTR item) 00087 { 00088 int len; 00089 rep_list *new_rep; 00090 00091 new_rep = reinterpret_cast<rep_list *>(HeapAlloc(GetProcessHeap(), 0, sizeof(rep_list))); 00092 if (new_rep == NULL) 00093 return E_OUTOFMEMORY; 00094 00095 new_rep->key_len = lstrlenW(key); 00096 new_rep->key = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, (new_rep->key_len + 1) * sizeof(OLECHAR))); 00097 if (new_rep->key == NULL) 00098 { 00099 HeapFree(GetProcessHeap(), 0, new_rep); 00100 return E_OUTOFMEMORY; 00101 } 00102 memcpy(new_rep->key, key, (new_rep->key_len + 1) * sizeof(OLECHAR)); 00103 00104 len = lstrlenW(item) + 1; 00105 new_rep->item = reinterpret_cast<OLECHAR *>(HeapAlloc(GetProcessHeap(), 0, len * sizeof(OLECHAR))); 00106 if (new_rep->item == NULL) 00107 { 00108 HeapFree(GetProcessHeap(), 0, new_rep->key); 00109 HeapFree(GetProcessHeap(), 0, new_rep); 00110 return E_OUTOFMEMORY; 00111 } 00112 memcpy(new_rep->item, item, len * sizeof(OLECHAR)); 00113 00114 new_rep->next = m_rep; 00115 m_rep = new_rep; 00116 00117 return S_OK; 00118 } 00119 00120 HRESULT STDMETHODCALLTYPE ClearReplacements() 00121 { 00122 rep_list *iter; 00123 rep_list *iter2; 00124 00125 iter = m_rep; 00126 while (iter) 00127 { 00128 iter2 = iter->next; 00129 HeapFree(GetProcessHeap(), 0, iter->key); 00130 HeapFree(GetProcessHeap(), 0, iter->item); 00131 HeapFree(GetProcessHeap(), 0, iter); 00132 iter = iter2; 00133 } 00134 00135 m_rep = NULL; 00136 return S_OK; 00137 } 00138 00139 HRESULT STDMETHODCALLTYPE ResourceRegisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType) 00140 { 00141 return RegisterWithResource(resFileName, szID, szType, TRUE); 00142 } 00143 00144 HRESULT STDMETHODCALLTYPE ResourceUnregisterSz(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType) 00145 { 00146 return RegisterWithResource(resFileName, szID, szType, FALSE); 00147 } 00148 00149 HRESULT STDMETHODCALLTYPE FileRegister(LPCOLESTR fileName) 00150 { 00151 return RegisterWithFile(fileName, TRUE); 00152 } 00153 00154 HRESULT STDMETHODCALLTYPE FileUnregister(LPCOLESTR fileName) 00155 { 00156 return RegisterWithFile(fileName, FALSE); 00157 } 00158 00159 HRESULT STDMETHODCALLTYPE StringRegister(LPCOLESTR data) 00160 { 00161 return RegisterWithString(data, TRUE); 00162 } 00163 00164 HRESULT STDMETHODCALLTYPE StringUnregister(LPCOLESTR data) 00165 { 00166 return RegisterWithString(data, FALSE); 00167 } 00168 00169 HRESULT STDMETHODCALLTYPE ResourceRegister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType) 00170 { 00171 return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType); 00172 } 00173 00174 HRESULT STDMETHODCALLTYPE ResourceUnregister(LPCOLESTR resFileName, UINT nID, LPCOLESTR szType) 00175 { 00176 return ResourceRegisterSz(resFileName, MAKEINTRESOURCEW(nID), szType); 00177 } 00178 00179 protected: 00180 HRESULT STDMETHODCALLTYPE RegisterWithResource(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL doRegister) 00181 { 00182 return resource_register(resFileName, szID, szType, doRegister); 00183 } 00184 00185 HRESULT STDMETHODCALLTYPE RegisterWithFile(LPCOLESTR fileName, BOOL doRegister) 00186 { 00187 return file_register(fileName, doRegister); 00188 } 00189 00190 HRESULT STDMETHODCALLTYPE RegisterWithString(LPCOLESTR data, BOOL doRegister) 00191 { 00192 return string_register(data, doRegister); 00193 } 00194 00195 private: 00196 inline LONG RegDeleteTreeX(HKEY parentKey, LPCTSTR subKeyName) 00197 { 00198 wchar_t szBuffer[256]; 00199 DWORD dwSize; 00200 FILETIME time; 00201 HKEY childKey; 00202 LONG lRes; 00203 00204 ATLASSERT(parentKey != NULL); 00205 lRes = RegOpenKeyEx(parentKey, subKeyName, 0, KEY_READ | KEY_WRITE, &childKey); 00206 if (lRes != ERROR_SUCCESS) 00207 return lRes; 00208 00209 dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]); 00210 while (RegEnumKeyExW(parentKey, 0, szBuffer, &dwSize, NULL, NULL, NULL, &time) == ERROR_SUCCESS) 00211 { 00212 lRes = RegDeleteTreeX(childKey, szBuffer); 00213 if (lRes != ERROR_SUCCESS) 00214 return lRes; 00215 dwSize = sizeof(szBuffer) / sizeof(szBuffer[0]); 00216 } 00217 RegCloseKey(childKey); 00218 return RegDeleteKey(parentKey, subKeyName); 00219 } 00220 00221 HRESULT strbuf_init(strbuf *buf) 00222 { 00223 buf->str = reinterpret_cast<LPOLESTR>(HeapAlloc(GetProcessHeap(), 0, 128 * sizeof(WCHAR))); 00224 if (buf->str == NULL) 00225 return E_OUTOFMEMORY; 00226 buf->alloc = 128; 00227 buf->len = 0; 00228 return S_OK; 00229 } 00230 00231 HRESULT strbuf_write(LPCOLESTR str, strbuf *buf, int len) 00232 { 00233 LPOLESTR newBuffer; 00234 00235 if (len == -1) 00236 len = lstrlenW(str); 00237 if (buf->len + len + 1 >= buf->alloc) 00238 { 00239 buf->alloc = (buf->len + len) * 2; 00240 newBuffer = reinterpret_cast<LPOLESTR>(HeapReAlloc(GetProcessHeap(), 0, buf->str, buf->alloc * sizeof(WCHAR))); 00241 if (newBuffer == NULL) 00242 return E_OUTOFMEMORY; 00243 buf->str = newBuffer; 00244 } 00245 memcpy(buf->str + buf->len, str, len * sizeof(OLECHAR)); 00246 buf->len += len; 00247 buf->str[buf->len] = '\0'; 00248 return S_OK; 00249 } 00250 00251 00252 HRESULT file_register(LPCOLESTR fileName, BOOL do_register) 00253 { 00254 HANDLE file; 00255 DWORD filelen; 00256 DWORD len; 00257 LPWSTR regstrw; 00258 LPSTR regstra; 00259 LRESULT lres; 00260 HRESULT hResult; 00261 00262 file = CreateFileW(fileName, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_READONLY, NULL); 00263 if (file != INVALID_HANDLE_VALUE) 00264 { 00265 filelen = GetFileSize(file, NULL); 00266 regstra = reinterpret_cast<LPSTR>(HeapAlloc(GetProcessHeap(), 0, filelen)); 00267 if (regstra == NULL) 00268 return E_OUTOFMEMORY; 00269 lres = ReadFile(file, regstra, filelen, NULL, NULL); 00270 if (lres == ERROR_SUCCESS) 00271 { 00272 len = MultiByteToWideChar(CP_ACP, 0, regstra, filelen, NULL, 0) + 1; 00273 regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR))); 00274 if (regstra == NULL) 00275 { 00276 HeapFree(GetProcessHeap(), 0, regstra); 00277 return E_OUTOFMEMORY; 00278 } 00279 MultiByteToWideChar(CP_ACP, 0, regstra, filelen, regstrw, len); 00280 regstrw[len - 1] = '\0'; 00281 00282 hResult = string_register(regstrw, do_register); 00283 00284 HeapFree(GetProcessHeap(), 0, regstrw); 00285 } 00286 else 00287 { 00288 hResult = HRESULT_FROM_WIN32(lres); 00289 } 00290 HeapFree(GetProcessHeap(), 0, regstra); 00291 CloseHandle(file); 00292 } 00293 else 00294 { 00295 hResult = HRESULT_FROM_WIN32(GetLastError()); 00296 } 00297 00298 return hResult; 00299 } 00300 00301 HRESULT resource_register(LPCOLESTR resFileName, LPCOLESTR szID, LPCOLESTR szType, BOOL do_register) 00302 { 00303 HINSTANCE hins; 00304 HRSRC src; 00305 HGLOBAL regstra; 00306 LPWSTR regstrw; 00307 DWORD len; 00308 DWORD reslen; 00309 HRESULT hResult; 00310 00311 hins = LoadLibraryExW(resFileName, NULL, LOAD_LIBRARY_AS_DATAFILE); 00312 if (hins) 00313 { 00314 src = FindResourceW(hins, szID, szType); 00315 if (src) 00316 { 00317 regstra = LoadResource(hins, src); 00318 reslen = SizeofResource(hins, src); 00319 if (regstra) 00320 { 00321 len = MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, NULL, 0) + 1; 00322 regstrw = reinterpret_cast<LPWSTR>(HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len * sizeof(WCHAR))); 00323 if (regstrw == NULL) 00324 return E_OUTOFMEMORY; 00325 MultiByteToWideChar(CP_ACP, 0, reinterpret_cast<LPCSTR>(regstra), reslen, regstrw, len); 00326 regstrw[len - 1] = '\0'; 00327 00328 hResult = string_register(regstrw, do_register); 00329 00330 HeapFree(GetProcessHeap(), 0, regstrw); 00331 } 00332 else 00333 hResult = HRESULT_FROM_WIN32(GetLastError()); 00334 } 00335 else 00336 hResult = HRESULT_FROM_WIN32(GetLastError()); 00337 FreeLibrary(hins); 00338 } 00339 else 00340 hResult = HRESULT_FROM_WIN32(GetLastError()); 00341 00342 return hResult; 00343 } 00344 00345 HRESULT string_register(LPCOLESTR data, BOOL do_register) 00346 { 00347 strbuf buf; 00348 HRESULT hResult; 00349 00350 hResult = strbuf_init(&buf); 00351 if (FAILED(hResult)) 00352 return hResult; 00353 hResult = do_preprocess(data, &buf); 00354 if (SUCCEEDED(hResult)) 00355 { 00356 hResult = do_process_root_key(buf.str, do_register); 00357 if (FAILED(hResult) && do_register) 00358 do_process_root_key(buf.str, FALSE); 00359 } 00360 00361 HeapFree(GetProcessHeap(), 0, buf.str); 00362 return hResult; 00363 } 00364 00365 HRESULT do_preprocess(LPCOLESTR data, strbuf *buf) 00366 { 00367 LPCOLESTR iter; 00368 LPCOLESTR iter2; 00369 rep_list *rep_iter; 00370 HRESULT hResult; 00371 00372 iter2 = data; 00373 iter = wcschr(data, '%'); 00374 while (iter) 00375 { 00376 hResult = strbuf_write(iter2, buf, static_cast<int>(iter - iter2)); 00377 if (FAILED(hResult)) 00378 return hResult; 00379 00380 iter2 = ++iter; 00381 if (!*iter2) 00382 return DISP_E_EXCEPTION; 00383 iter = wcschr(iter2, '%'); 00384 if (!iter) 00385 return DISP_E_EXCEPTION; 00386 00387 if (iter == iter2) 00388 { 00389 hResult = strbuf_write(_T("%"), buf, 1); 00390 if (FAILED(hResult)) 00391 return hResult; 00392 } 00393 else 00394 { 00395 for (rep_iter = m_rep; rep_iter; rep_iter = rep_iter->next) 00396 { 00397 if (rep_iter->key_len == iter - iter2 && !_memicmp(iter2, rep_iter->key, rep_iter->key_len * sizeof(wchar_t))) 00398 break; 00399 } 00400 if (!rep_iter) 00401 return DISP_E_EXCEPTION; 00402 00403 hResult = strbuf_write(rep_iter->item, buf, -1); 00404 if (FAILED(hResult)) 00405 return hResult; 00406 } 00407 00408 iter2 = ++iter; 00409 iter = wcschr(iter, '%'); 00410 } 00411 00412 hResult = strbuf_write(iter2, buf, -1); 00413 if (FAILED(hResult)) 00414 return hResult; 00415 00416 return S_OK; 00417 } 00418 00419 HRESULT get_word(LPCOLESTR *str, strbuf *buf) 00420 { 00421 LPCOLESTR iter; 00422 LPCOLESTR iter2; 00423 HRESULT hResult; 00424 00425 iter2 = *str; 00426 buf->len = 0; 00427 buf->str[0] = '\0'; 00428 00429 while (iswspace (*iter2)) 00430 iter2++; 00431 iter = iter2; 00432 if (!*iter) 00433 { 00434 *str = iter; 00435 return S_OK; 00436 } 00437 00438 if (*iter == '}' || *iter == '=') 00439 { 00440 hResult = strbuf_write(iter++, buf, 1); 00441 if (FAILED(hResult)) 00442 return hResult; 00443 } 00444 else if (*iter == '\'') 00445 { 00446 iter2 = ++iter; 00447 iter = wcschr(iter, '\''); 00448 if (!iter) 00449 { 00450 *str = iter; 00451 return DISP_E_EXCEPTION; 00452 } 00453 hResult = strbuf_write(iter2, buf, static_cast<int>(iter - iter2)); 00454 if (FAILED(hResult)) 00455 return hResult; 00456 iter++; 00457 } 00458 else 00459 { 00460 while (*iter && !iswspace(*iter)) 00461 iter++; 00462 hResult = strbuf_write(iter2, buf, static_cast<int>(iter - iter2)); 00463 if (FAILED(hResult)) 00464 return hResult; 00465 } 00466 00467 while (iswspace(*iter)) 00468 iter++; 00469 *str = iter; 00470 return S_OK; 00471 } 00472 00473 inline unsigned int HexToBin(OLECHAR a) 00474 { 00475 if (a >= '0' && a <= '9') 00476 return a - '0'; 00477 if (a >= 'A' && a <= 'F') 00478 return a - 'A' + 10; 00479 if (a >= 'a' && a <= 'f') 00480 return a - 'a' + 10; 00481 ATLASSERT(false); 00482 return 0; 00483 } 00484 00485 HRESULT do_process_key(LPCOLESTR *pstr, HKEY parent_key, strbuf *buf, BOOL do_register) 00486 { 00487 LPCOLESTR iter; 00488 HRESULT hres; 00489 LONG lres; 00490 HKEY hkey; 00491 strbuf name; 00492 00493 enum { 00494 NORMAL, 00495 NO_REMOVE, 00496 IS_VAL, 00497 FORCE_REMOVE, 00498 DO_DELETE 00499 } key_type = NORMAL; 00500 00501 static const wchar_t *wstrNoRemove = _T("NoRemove"); 00502 static const wchar_t *wstrForceRemove = _T("ForceRemove"); 00503 static const wchar_t *wstrDelete = _T("Delete"); 00504 static const wchar_t *wstrval = _T("val"); 00505 00506 iter = *pstr; 00507 hkey = NULL; 00508 iter = *pstr; 00509 hres = get_word(&iter, buf); 00510 if (FAILED(hres)) 00511 return hres; 00512 hres = strbuf_init(&name); 00513 if (FAILED(hres)) 00514 return hres; 00515 00516 while(buf->str[1] || buf->str[0] != '}') 00517 { 00518 key_type = NORMAL; 00519 if (!lstrcmpiW(buf->str, wstrNoRemove)) 00520 key_type = NO_REMOVE; 00521 else if (!lstrcmpiW(buf->str, wstrForceRemove)) 00522 key_type = FORCE_REMOVE; 00523 else if (!lstrcmpiW(buf->str, wstrval)) 00524 key_type = IS_VAL; 00525 else if (!lstrcmpiW(buf->str, wstrDelete)) 00526 key_type = DO_DELETE; 00527 00528 if (key_type != NORMAL) 00529 { 00530 hres = get_word(&iter, buf); 00531 if (FAILED(hres)) 00532 break; 00533 } 00534 00535 if (do_register) 00536 { 00537 if (key_type == IS_VAL) 00538 { 00539 hkey = parent_key; 00540 hres = strbuf_write(buf->str, &name, -1); 00541 if (FAILED(hres)) 00542 return hres; 00543 } 00544 else if (key_type == DO_DELETE) 00545 { 00546 RegDeleteTreeX(parent_key, buf->str); 00547 } 00548 else 00549 { 00550 if (key_type == FORCE_REMOVE) 00551 RegDeleteTreeX(parent_key, buf->str); 00552 lres = RegCreateKey(parent_key, buf->str, &hkey); 00553 if (lres != ERROR_SUCCESS) 00554 { 00555 hres = HRESULT_FROM_WIN32(lres); 00556 break; 00557 } 00558 } 00559 } 00560 else if (key_type != IS_VAL && key_type != DO_DELETE) 00561 { 00562 hres = strbuf_write(buf->str, &name, -1); 00563 if (FAILED(hres)) 00564 return hres; 00565 lres = RegOpenKey(parent_key, buf->str, &hkey); 00566 if (lres != ERROR_SUCCESS) 00567 { 00568 } 00569 } 00570 00571 if (key_type != DO_DELETE && *iter == '=') 00572 { 00573 iter++; 00574 hres = get_word(&iter, buf); 00575 if (FAILED(hres)) 00576 break; 00577 if (buf->len != 1) 00578 { 00579 hres = DISP_E_EXCEPTION; 00580 break; 00581 } 00582 if (do_register) 00583 { 00584 switch(buf->str[0]) 00585 { 00586 case 's': 00587 hres = get_word(&iter, buf); 00588 if (FAILED(hres)) 00589 break; 00590 lres = RegSetValueEx(hkey, name.len ? name.str : NULL, 0, REG_SZ, (PBYTE)buf->str, 00591 (lstrlenW(buf->str) + 1) * sizeof(WCHAR)); 00592 if (lres != ERROR_SUCCESS) 00593 hres = HRESULT_FROM_WIN32(lres); 00594 break; 00595 case 'e': 00596 hres = get_word(&iter, buf); 00597 if (FAILED(hres)) 00598 break; 00599 lres = RegSetValueEx(hkey, name.len ? name.str : NULL, 0, REG_EXPAND_SZ, (PBYTE)buf->str, 00600 (lstrlenW(buf->str) + 1) * sizeof(WCHAR)); 00601 if (lres != ERROR_SUCCESS) 00602 hres = HRESULT_FROM_WIN32(lres); 00603 break; 00604 case 'd': 00605 { 00606 hres = get_word(&iter, buf); 00607 if (FAILED(hres)) 00608 break; 00609 WCHAR *end; 00610 DWORD dw; 00611 if ((buf->str[0] == '0' && buf->str[1] == 'x') || (buf->str[0] == '&' && buf->str[1] == 'H')) 00612 dw = wcstoul(&buf->str[2], &end, 16); 00613 else 00614 dw = wcstol(&buf->str[0], &end, 10); 00615 lres = RegSetValueEx(hkey, name.len ? name.str : NULL, 0, REG_DWORD, (PBYTE)&dw, sizeof(dw)); 00616 if (lres != ERROR_SUCCESS) 00617 hres = HRESULT_FROM_WIN32(lres); 00618 break; 00619 } 00620 case 'b': 00621 { 00622 DWORD count; 00623 DWORD curIndex; 00624 00625 hres = get_word(&iter, buf); 00626 if (FAILED(hres)) 00627 break; 00628 count = buf->len; 00629 if ((count & 1) != 0) 00630 return DISP_E_EXCEPTION; 00631 count = count / 2; 00632 for (curIndex = 0; curIndex < count; curIndex++) 00633 ((BYTE*)buf->str)[curIndex] = (HexToBin(buf->str[curIndex * 2]) << 4) | HexToBin(buf->str[curIndex * 2 + 1]); 00634 lres = RegSetValueEx(hkey, name.len ? name.str : NULL, 0, REG_BINARY, (PBYTE)buf->str, count); 00635 if (lres != ERROR_SUCCESS) 00636 hres = HRESULT_FROM_WIN32(lres); 00637 break; 00638 } 00639 default: 00640 hres = DISP_E_EXCEPTION; 00641 } 00642 if (FAILED(hres)) 00643 break; 00644 } 00645 else 00646 { 00647 if (*iter == '-') 00648 iter++; 00649 hres = get_word(&iter, buf); 00650 if (FAILED(hres)) 00651 break; 00652 } 00653 } 00654 else if(key_type == IS_VAL) 00655 { 00656 hres = DISP_E_EXCEPTION; 00657 break; 00658 } 00659 00660 if (key_type != IS_VAL && key_type != DO_DELETE && *iter == '{' && iswspace(iter[1])) 00661 { 00662 hres = get_word(&iter, buf); 00663 if (FAILED(hres)) 00664 break; 00665 hres = do_process_key(&iter, hkey, buf, do_register); 00666 if (FAILED(hres)) 00667 break; 00668 } 00669 00670 if (!do_register && (key_type == NORMAL || key_type == FORCE_REMOVE)) 00671 { 00672 RegDeleteKey(parent_key, name.str); 00673 } 00674 00675 if (hkey && key_type != IS_VAL) 00676 RegCloseKey(hkey); 00677 hkey = 0; 00678 name.len = 0; 00679 00680 hres = get_word(&iter, buf); 00681 if (FAILED(hres)) 00682 break; 00683 } 00684 00685 HeapFree(GetProcessHeap(), 0, name.str); 00686 if (hkey && key_type != IS_VAL) 00687 RegCloseKey(hkey); 00688 *pstr = iter; 00689 return hres; 00690 } 00691 00692 HRESULT do_process_root_key(LPCOLESTR data, BOOL do_register) 00693 { 00694 LPCOLESTR iter; 00695 strbuf buf; 00696 unsigned int i; 00697 HRESULT hResult; 00698 static const struct { 00699 const wchar_t *name; 00700 HKEY key; 00701 } root_keys[] = { 00702 {_T("HKEY_CLASSES_ROOT"), HKEY_CLASSES_ROOT}, 00703 {_T("HKEY_CURRENT_USER"), HKEY_CURRENT_USER}, 00704 {_T("HKEY_LOCAL_MACHINE"), HKEY_LOCAL_MACHINE}, 00705 {_T("HKEY_USERS"), HKEY_USERS}, 00706 {_T("HKEY_PERFORMANCE_DATA"), HKEY_PERFORMANCE_DATA}, 00707 {_T("HKEY_DYN_DATA"), HKEY_DYN_DATA}, 00708 {_T("HKEY_CURRENT_CONFIG"), HKEY_CURRENT_CONFIG}, 00709 {_T("HKCR"), HKEY_CLASSES_ROOT}, 00710 {_T("HKCU"), HKEY_CURRENT_USER}, 00711 {_T("HKLM"), HKEY_LOCAL_MACHINE}, 00712 {_T("HKU"), HKEY_USERS}, 00713 {_T("HKPD"), HKEY_PERFORMANCE_DATA}, 00714 {_T("HKDD"), HKEY_DYN_DATA}, 00715 {_T("HKCC"), HKEY_CURRENT_CONFIG}, 00716 }; 00717 00718 iter = data; 00719 00720 hResult = strbuf_init(&buf); 00721 if (FAILED(hResult)) 00722 return hResult; 00723 hResult = get_word(&iter, &buf); 00724 if (FAILED(hResult)) 00725 return hResult; 00726 00727 while (*iter) 00728 { 00729 if (!buf.len) 00730 { 00731 hResult = DISP_E_EXCEPTION; 00732 break; 00733 } 00734 for (i = 0; i < sizeof(root_keys) / sizeof(root_keys[0]); i++) 00735 { 00736 if (!lstrcmpiW(buf.str, root_keys[i].name)) 00737 break; 00738 } 00739 if (i == sizeof(root_keys) / sizeof(root_keys[0])) 00740 { 00741 hResult = DISP_E_EXCEPTION; 00742 break; 00743 } 00744 hResult = get_word(&iter, &buf); 00745 if (FAILED(hResult)) 00746 break; 00747 if (buf.str[1] || buf.str[0] != '{') 00748 { 00749 hResult = DISP_E_EXCEPTION; 00750 break; 00751 } 00752 hResult = do_process_key(&iter, root_keys[i].key, &buf, do_register); 00753 if (FAILED(hResult)) 00754 break; 00755 hResult = get_word(&iter, &buf); 00756 if (FAILED(hResult)) 00757 break; 00758 } 00759 HeapFree(GetProcessHeap(), 0, buf.str); 00760 return hResult; 00761 } 00762 00763 }; 00764 00765 }; //namespace ATL
Generated on Sun May 27 2012 04:35:56 for ReactOS by
1.7.6.1
