- Fix gdb2 and regexpl warnings under gcc 4.4.0
[reactos.git] / rosapps / applications / sysutils / regexpl / RegistryTree.cpp
1 /* $Id$
2 *
3 * regexpl - Console Registry Explorer
4 *
5 * Copyright (C) 2000-2005 Nedko Arnaudov <nedko@users.sourceforge.net>
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; see the file COPYING. If not, write to
19 * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 * Boston, MA 02111-1307, USA.
21 */
22
23 // RegistryTree.cpp: implementation of the CRegistryTree class.
24
25 #include "ph.h"
26 #include "RegistryTree.h"
27 #include "Pattern.h"
28 #include "RegistryExplorer.h"
29
30 CRegistryTree::CRegistryTree()
31 {
32 m_pszMachineName = NULL;
33 VERIFY(SUCCEEDED(m_Root.m_Key.InitRoot()));
34 m_Root.m_pUp = NULL;
35 m_pCurrentKey = &m_Root;
36 ASSERT(m_pCurrentKey->m_Key.IsRoot());
37 m_ErrorMsg[ERROR_MSG_BUFFER_SIZE] = 0;
38 }
39
40 CRegistryTree::CRegistryTree(const CRegistryTree& Tree)
41 {
42 m_pszMachineName = NULL;
43 VERIFY(SUCCEEDED(m_Root.m_Key.InitRoot()));
44 m_Root.m_pUp = NULL;
45 m_pCurrentKey = &m_Root;
46 ASSERT(m_pCurrentKey->m_Key.IsRoot());
47
48 const TCHAR *pszPath = Tree.GetCurrentPath();
49 if ((pszPath[0] == _T('\\')) && (pszPath[1] == _T('\\')))
50 { // path has machine name
51 pszPath += 2;
52 while (*pszPath && (*pszPath != _T('\\')))
53 pszPath++;
54
55 ASSERT(*pszPath == _T('\\')); // if path begins with \\ it must be followed by machine name
56 }
57
58 if (Tree.m_pszMachineName)
59 SetMachineName(Tree.m_pszMachineName);
60
61 VERIFY(ChangeCurrentKey(pszPath));
62 }
63
64 CRegistryTree::~CRegistryTree()
65 {
66 if (m_pszMachineName)
67 delete m_pszMachineName;
68
69 CNode *pNode;
70 while(m_pCurrentKey->m_pUp)
71 {
72 pNode = m_pCurrentKey;
73 m_pCurrentKey = m_pCurrentKey->m_pUp;
74 delete pNode;
75 }
76
77 // We are on root
78 ASSERT(m_pCurrentKey->m_Key.IsRoot());
79 ASSERT(m_pCurrentKey == &m_Root);
80 }
81
82 const TCHAR * CRegistryTree::GetCurrentPath() const
83 {
84 return m_pCurrentKey->m_Key.GetKeyName();
85 }
86
87 BOOL CRegistryTree::IsCurrentRoot()
88 {
89 return m_pCurrentKey->m_Key.IsRoot();
90 }
91
92 BOOL CRegistryTree::ChangeCurrentKey(const TCHAR *pszRelativePath)
93 {
94 if (*pszRelativePath == _T('\\'))
95 GotoRoot(); // This is full absolute path.
96
97 // split path to key names.
98 const TCHAR *pszSeps = _T("\\");
99
100 // Make buffer and copy relative path into it.
101 TCHAR *pszBuffer = new TCHAR[_tcslen(pszRelativePath)+1];
102 if (!pszBuffer)
103 {
104 SetError(ERROR_OUTOFMEMORY);
105 return FALSE;
106 }
107
108 _tcscpy(pszBuffer,pszRelativePath);
109
110 // We accept names in form "\"blablabla\\blab labla\"\\"
111 size_t size = _tcslen(pszBuffer);
112 if (size)
113 {
114 if (pszBuffer[size-1] == _T('\\'))
115 pszBuffer[--size] = 0;
116
117 TCHAR *psz;
118 if (*pszBuffer == _T('\"') && (psz = _tcschr(pszBuffer+1,_T('\"'))) && size_t(psz-pszBuffer) == size-1)
119 {
120 size--;
121 pszBuffer[size] = 0;
122
123 pszBuffer++;
124 }
125 }
126
127 const TCHAR *pszNewKey = _tcstok(pszBuffer,pszSeps);
128
129 if ((!pszNewKey)&&((*pszRelativePath != _T('\\'))||(*(pszRelativePath+1) != 0)))
130 {
131 SetError(_T("Invalid key name"));
132 goto Abort;
133 };
134
135 // change keys
136 while (pszNewKey)
137 {
138 if (!InternalChangeCurrentKey(pszNewKey,KEY_READ))
139 goto Abort; // InternalChangeCurrentKey sets last error description
140
141 // Get next key name
142 pszNewKey = _tcstok(NULL,pszSeps);
143 }
144
145 return TRUE;
146
147 Abort:
148 delete pszBuffer;
149 return FALSE;
150 }
151
152 const TCHAR * CRegistryTree::GetLastErrorDescription()
153 {
154 return m_ErrorMsg;
155 }
156
157 void CRegistryTree::GotoRoot()
158 {
159 // Delete current tree
160 CNode *pNode;
161 while(m_pCurrentKey->m_pUp)
162 {
163 pNode = m_pCurrentKey;
164 m_pCurrentKey = m_pCurrentKey->m_pUp;
165 delete pNode;
166 }
167
168 // We are on root
169 ASSERT(m_pCurrentKey->m_Key.IsRoot());
170 ASSERT(m_pCurrentKey == &m_Root);
171 }
172
173 BOOL CRegistryTree::SetMachineName(LPCTSTR pszMachineName)
174 {
175 GotoRoot();
176
177 // If we are going to local machine...
178 if (pszMachineName == NULL)
179 {
180 // Delete previous machine name buffer if allocated.
181 if (m_pszMachineName)
182 delete m_pszMachineName;
183
184 m_pszMachineName = NULL;
185 m_Root.m_Key.InitRoot();
186 return TRUE;
187 }
188
189 // Skip leading backslashes if any.
190 while ((*pszMachineName)&&(*pszMachineName == _T('\\')))
191 pszMachineName++;
192
193 ASSERT(*pszMachineName); // No machine name.
194
195 TCHAR *pszNewMachineName = new TCHAR[_tcslen(pszMachineName)+3]; // two leading backslashes + terminating null
196
197 if (!pszMachineName)
198 {
199 SetError(ERROR_OUTOFMEMORY);
200 return FALSE;
201 }
202
203 // Delete previous machine name buffer if allocated.
204 if (m_pszMachineName)
205 delete m_pszMachineName;
206
207 m_pszMachineName = pszNewMachineName;
208
209 _tcscpy(m_pszMachineName,_T("\\\\")); // leading backslashes
210 _tcscpy(m_pszMachineName+2,pszMachineName); // machine name itself
211 _tcsupr(m_pszMachineName+2); // upercase it
212
213 VERIFY(SUCCEEDED(m_Root.m_Key.InitRoot(m_pszMachineName)));
214 return TRUE;
215 }
216
217 BOOL CRegistryTree::NewKey(const TCHAR *pszKeyName, const TCHAR *pszPath, BOOL blnVolatile)
218 {
219 if (!m_pCurrentKey)
220 {
221 SetErrorCommandNAOnRoot(_T("Creating new key "));
222 return FALSE;
223 }
224
225 CRegistryTree Tree(*this);
226 if (!Tree.ChangeCurrentKey(pszPath))
227 {
228 SetError(Tree.GetLastErrorDescription());
229 return FALSE;
230 }
231
232 BOOL blnOpened;
233 HKEY hKey;
234
235 LONG nError = Tree.m_pCurrentKey->m_Key.CreateSubkey(KEY_READ,
236 pszKeyName,
237 hKey,
238 &blnOpened,
239 blnVolatile);
240 if (nError == ERROR_SUCCESS)
241 {
242 LONG nError = RegCloseKey(hKey);
243 ASSERT(nError == ERROR_SUCCESS);
244 }
245
246 if ((nError == ERROR_SUCCESS) && blnOpened)
247 {
248 SetError(_T("A key \"%s\" already exists."),pszKeyName);
249 return FALSE;
250 }
251
252 if (nError != ERROR_SUCCESS)
253 {
254 SetError(_T("Cannot create key : %s%s\nError %d (%s)\n"),
255 GetCurrentPath(),pszKeyName,nError,GetErrorDescription(nError));
256
257 return FALSE;
258 }
259
260 return TRUE;
261 }
262
263 BOOL CRegistryTree::DeleteSubkeys(const TCHAR *pszKeyPattern, const TCHAR *pszPath, BOOL blnRecursive)
264 {
265 CRegistryKey Key;
266 if (!GetKey(pszPath,KEY_QUERY_VALUE|KEY_ENUMERATE_SUB_KEYS|DELETE,Key))
267 return FALSE;
268
269 return DeleteSubkeys(Key, pszKeyPattern, blnRecursive);
270 }
271
272 BOOL CRegistryTree::DeleteSubkeys(CRegistryKey& rKey, const TCHAR *pszKeyPattern, BOOL blnRecursive)
273 {
274 LONG nError;
275
276 // enumerate subkeys
277 DWORD dwMaxSubkeyNameLength;
278 nError = rKey.GetSubkeyNameMaxLength(dwMaxSubkeyNameLength);
279 if (nError != ERROR_SUCCESS)
280 {
281 SetError(_T("Cannot delete subkeys(s) of key %s.\nRequesting info about key failed.\nError %d (%s)\n"),
282 rKey.GetKeyName(),nError,GetErrorDescription(nError));
283 return FALSE;
284 }
285
286 TCHAR *pszSubkeyName = new TCHAR [dwMaxSubkeyNameLength];
287 rKey.InitSubkeyEnumeration(pszSubkeyName, dwMaxSubkeyNameLength);
288 BOOL blnKeyDeleted = FALSE;
289 while ((nError = rKey.GetNextSubkeyName()) == ERROR_SUCCESS)
290 {
291 if (PatternMatch(pszKeyPattern,pszSubkeyName))
292 {
293 if (blnRecursive)
294 { // deltion is recursive, delete subkey subkeys
295 CRegistryKey Subkey;
296 // open subkey
297 nError = rKey.OpenSubkey(DELETE,pszSubkeyName,Subkey);
298 // delete subkey subkeys
299 if (DeleteSubkeys(Subkey, PATTERN_MATCH_ALL, TRUE))
300 {
301 AddErrorDescription(_T("Cannot delete subkey(s) of key %s. Subkey deletion failed.\n"),Subkey.GetKeyName());
302 return FALSE;
303 }
304 }
305
306 nError = rKey.DeleteSubkey(pszSubkeyName);
307 if (nError != ERROR_SUCCESS)
308 {
309 SetError(_T("Cannot delete the %s subkey of key %s.\nError %d (%s)\n"),
310 pszSubkeyName,rKey.GetKeyName(),nError,GetErrorDescription(nError));
311
312 return FALSE;
313 }
314 blnKeyDeleted = TRUE;
315 rKey.InitSubkeyEnumeration(pszSubkeyName, dwMaxSubkeyNameLength); // reset iteration
316 }
317 }
318
319 ASSERT(nError != ERROR_SUCCESS);
320 if (nError != ERROR_NO_MORE_ITEMS)
321 {
322 SetError(_T("Cannot delete subkeys(s) of key %s.\nSubkey enumeration failed.\nError %d (%s)\n"),
323 rKey.GetKeyName(),nError,GetErrorDescription(nError));
324 return FALSE;
325 }
326
327 if (!blnKeyDeleted)
328 SetError(_T("The key %s has no subkeys that match %s pattern.\n"),rKey.GetKeyName(),pszKeyPattern);
329
330 return blnKeyDeleted;
331 }
332
333 const TCHAR * CRegistryTree::GetErrorDescription(LONG nError)
334 {
335 switch(nError)
336 {
337 case ERROR_ACCESS_DENIED:
338 return _T("Access denied");
339 case ERROR_FILE_NOT_FOUND:
340 return _T("The system cannot find the key specified");
341 case ERROR_INTERNAL_ERROR:
342 return _T("Internal error");
343 case ERROR_OUTOFMEMORY:
344 return _T("Out of memory");
345 default:
346 return _T("Unknown error");
347 }
348 }
349
350 void CRegistryTree::SetError(LONG nError)
351 {
352 SetError(_T("Error %u (%s)"),nError,GetErrorDescription(nError));
353 }
354
355 void CRegistryTree::SetError(const TCHAR *pszFormat, ...)
356 {
357 va_list args;
358 va_start(args,pszFormat);
359 if (_vsntprintf(m_ErrorMsg,ERROR_MSG_BUFFER_SIZE,pszFormat,args) < 0)
360 m_ErrorMsg[ERROR_MSG_BUFFER_SIZE] = 0;
361 va_end(args);
362 }
363
364 void CRegistryTree::SetInternalError()
365 {
366 SetError(_T("Internal Error"));
367 }
368
369 void CRegistryTree::AddErrorDescription(const TCHAR *pszFormat, ...)
370 {
371 size_t size = _tcslen(m_ErrorMsg);
372 if (size < ERROR_MSG_BUFFER_SIZE)
373 {
374 TCHAR *pszAdd = m_ErrorMsg+size;
375 va_list args;
376 va_start(args,pszFormat);
377 size = ERROR_MSG_BUFFER_SIZE-size;
378 if (_vsntprintf(pszAdd,size,pszFormat,args) < 0)
379 m_ErrorMsg[size] = 0;
380 va_end(args);
381 }
382 }
383
384 void CRegistryTree::SetErrorCommandNAOnRoot(const TCHAR *pszCommand)
385 {
386 ASSERT(pszCommand);
387 if (pszCommand)
388 SetError(_T("%s") COMMAND_NA_ON_ROOT,pszCommand);
389 else
390 SetInternalError();
391 }
392
393 BOOL CRegistryTree::InternalChangeCurrentKey(const TCHAR *pszSubkeyName, REGSAM DesiredAccess)
394 {
395 size_t size = _tcslen(pszSubkeyName);
396 TCHAR *pszSubkeyNameBuffer = new TCHAR[size+3];
397 if (!pszSubkeyNameBuffer)
398 {
399 SetError(_T("Cannot open key : %s%s\nError %d (%s)\n"),
400 GetCurrentPath(),pszSubkeyName,ERROR_OUTOFMEMORY,GetErrorDescription(ERROR_OUTOFMEMORY));
401 }
402
403 _tcscpy(pszSubkeyNameBuffer,pszSubkeyName);
404 if (size && (pszSubkeyName[0] == _T('\"')) && (pszSubkeyName[size-1] == _T('\"')))
405 {
406 pszSubkeyNameBuffer[size-1] = 0;
407 pszSubkeyName = pszSubkeyNameBuffer+1;
408 }
409
410 if (_tcscmp(pszSubkeyName,_T(".")) == 0)
411 {
412 delete pszSubkeyNameBuffer;
413 return TRUE;
414 }
415
416 if (_tcscmp(pszSubkeyName,_T("..")) == 0)
417 {
418 // Up level abstraction
419 if (m_pCurrentKey->m_Key.IsRoot())
420 {
421 // We are on root
422 ASSERT(m_pCurrentKey->m_pUp == NULL);
423 SetError(_T("Cannot open key. The root is not child.\n"));
424 delete pszSubkeyNameBuffer;
425 return FALSE;
426 }
427
428 ASSERT(m_pCurrentKey->m_pUp);
429 if (!m_pCurrentKey->m_pUp)
430 {
431 SetInternalError();
432 delete pszSubkeyNameBuffer;
433 return FALSE;
434 }
435 CNode *pNode = m_pCurrentKey;
436 m_pCurrentKey = m_pCurrentKey->m_pUp;
437 delete pNode;
438 delete pszSubkeyNameBuffer;
439 return TRUE;
440 }
441
442 CNode *pNewKey = new CNode;
443 if (!pNewKey)
444 {
445 SetError(_T("Cannot open key : %s%s\nError %d (%s)\n"),
446 GetCurrentPath(),pszSubkeyName,ERROR_OUTOFMEMORY,GetErrorDescription(ERROR_OUTOFMEMORY));
447 delete pszSubkeyNameBuffer;
448 return FALSE;
449 }
450
451 if (!InternalGetSubkey(pszSubkeyName,DesiredAccess,pNewKey->m_Key))
452 {
453 delete pNewKey;
454 delete pszSubkeyNameBuffer;
455 return FALSE;
456 }
457 pNewKey->m_pUp = m_pCurrentKey;
458 m_pCurrentKey = pNewKey;
459
460 delete pszSubkeyNameBuffer;
461 return TRUE;
462 }
463
464 BOOL CRegistryTree::InternalGetSubkey(const TCHAR *pszSubkeyName, REGSAM DesiredAccess, CRegistryKey& rKey)
465 {
466 LONG nError;
467 HKEY hNewKey = NULL;
468 TCHAR *pszSubkeyNameCaseUpdated = NULL;
469
470 nError = m_pCurrentKey->m_Key.OpenSubkey(DesiredAccess,pszSubkeyName,hNewKey);
471
472 if (nError != ERROR_SUCCESS)
473 {
474 SetError(_T("Cannot open key : %s%s\nError %u (%s)\n"),
475 GetCurrentPath(),pszSubkeyName,nError,GetErrorDescription(nError));
476
477 return FALSE;
478 }
479
480 // enum subkeys to find the subkey and get its name in stored case.
481 DWORD dwMaxSubkeyNameLength;
482 nError = m_pCurrentKey->m_Key.GetSubkeyNameMaxLength(dwMaxSubkeyNameLength);
483 if (nError != ERROR_SUCCESS)
484 goto SkipCaseUpdate;
485
486 pszSubkeyNameCaseUpdated = new TCHAR [dwMaxSubkeyNameLength];
487 m_pCurrentKey->m_Key.InitSubkeyEnumeration(pszSubkeyNameCaseUpdated, dwMaxSubkeyNameLength);
488 while ((nError = m_pCurrentKey->m_Key.GetNextSubkeyName()) == ERROR_SUCCESS)
489 if (_tcsicmp(pszSubkeyNameCaseUpdated, pszSubkeyName) == 0)
490 break;
491
492 if (nError != ERROR_SUCCESS)
493 {
494 delete pszSubkeyNameCaseUpdated;
495 pszSubkeyNameCaseUpdated = NULL;
496 }
497
498 SkipCaseUpdate:
499
500 HRESULT hr;
501 ASSERT(hNewKey);
502 if (pszSubkeyNameCaseUpdated)
503 {
504 hr = rKey.Init(hNewKey,GetCurrentPath(),pszSubkeyNameCaseUpdated,DesiredAccess);
505 if (FAILED(hr))
506 {
507 if (hr == (HRESULT)E_OUTOFMEMORY)
508 SetError(_T("Cannot open key : %s%s\nError %d (%s)\n"),
509 GetCurrentPath(),pszSubkeyName,ERROR_OUTOFMEMORY,GetErrorDescription(ERROR_OUTOFMEMORY));
510 else
511 SetError(_T("Cannot open key : %s%s\nUnknown error\n"), GetCurrentPath(), pszSubkeyName);
512
513 goto Abort;
514 }
515
516 delete pszSubkeyNameCaseUpdated;
517 }
518 else
519 {
520 hr = rKey.Init(hNewKey,GetCurrentPath(),pszSubkeyName,DesiredAccess);
521 if (FAILED(hr))
522 {
523 if (hr == (HRESULT)E_OUTOFMEMORY)
524 SetError(_T("Cannot open key : %s%s\nError %d (%s)\n"),
525 GetCurrentPath(),pszSubkeyName,ERROR_OUTOFMEMORY,GetErrorDescription(ERROR_OUTOFMEMORY));
526 else
527 SetError(_T("Cannot open key : %s%s\nUnknown error \n"),
528 GetCurrentPath(),
529 pszSubkeyName);
530
531 goto Abort;
532 }
533 }
534
535 return TRUE;
536 Abort:
537 if (pszSubkeyNameCaseUpdated)
538 delete pszSubkeyNameCaseUpdated;
539
540 if (hNewKey)
541 {
542 LONG nError = RegCloseKey(hNewKey);
543 ASSERT(nError == ERROR_SUCCESS);
544 }
545
546 return FALSE;
547 }
548
549 BOOL CRegistryTree::GetKey(const TCHAR *pszRelativePath, REGSAM DesiredAccess, CRegistryKey& rKey)
550 {
551 CRegistryTree Tree(*this);
552
553 if (!Tree.ChangeCurrentKey(pszRelativePath))
554 {
555 SetError(Tree.GetLastErrorDescription());
556 return FALSE;
557 }
558
559 if (Tree.m_pCurrentKey->m_Key.IsRoot())
560 {
561 HRESULT hr = rKey.InitRoot(m_pszMachineName);
562 if (FAILED(hr))
563 {
564 if (hr == (HRESULT)E_OUTOFMEMORY)
565 SetError(_T("\nError %d (%s)\n"),
566 ERROR_OUTOFMEMORY,GetErrorDescription(ERROR_OUTOFMEMORY));
567 else
568 SetInternalError();
569 return FALSE;
570 }
571
572 return TRUE;
573 }
574
575 // open key with desired access
576
577 // may be call to DuplicateHandle() is better.
578 // registry key handles returned by the RegConnectRegistry function cannot be used in a call to DuplicateHandle.
579
580 // Get short key name now...
581 const TCHAR *pszKeyName = Tree.m_pCurrentKey->m_Key.GetKeyName();
582 if (pszKeyName == NULL)
583 {
584 SetInternalError();
585 return FALSE;
586 }
587
588 size_t size = _tcslen(pszKeyName);
589 ASSERT(size);
590 if (!size)
591 {
592 SetInternalError();
593 return FALSE;
594 }
595
596 const TCHAR *pszShortKeyName_ = pszKeyName + size-1;
597 pszShortKeyName_--; // skip ending backslash
598 size = 0;
599 while (pszShortKeyName_ >= pszKeyName)
600 {
601 if (*pszShortKeyName_ == _T('\\'))
602 break;
603 pszShortKeyName_--;
604 size++;
605 }
606
607 if (!size || (*pszShortKeyName_ != _T('\\')))
608 {
609 ASSERT(FALSE);
610 SetInternalError();
611 return FALSE;
612 }
613
614 TCHAR *pszShortKeyName = new TCHAR [size+1];
615 if (!pszShortKeyName)
616 {
617 SetError(ERROR_OUTOFMEMORY);
618 return FALSE;
619 }
620
621 memcpy(pszShortKeyName,pszShortKeyName_+1,size*sizeof(TCHAR));
622 pszShortKeyName[size] = 0;
623
624 // change to parent key
625 if (!Tree.InternalChangeCurrentKey(_T(".."),READ_CONTROL))
626 {
627 ASSERT(FALSE);
628 SetInternalError();
629 return FALSE;
630 }
631
632 // change back to target key
633 if (!Tree.InternalGetSubkey(pszShortKeyName,DesiredAccess,rKey))
634 {
635 SetError(Tree.GetLastErrorDescription());
636 return FALSE;
637 }
638
639 return TRUE;
640 }
641