setup_native/source/win32/customactions/reg4msdoc/registrywnt.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: registrywnt.cxx,v $
  10  * $Revision: 1.7 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 //---------------------------------------
  32 //
  33 //---------------------------------------
  34
  35 #ifdef _MSC_VER
  36 #pragma warning(push, 1) /* disable warnings within system headers */
  37 #endif
  38 #include <windows.h>
  39 #ifdef _MSC_VER
  40 #pragma warning(pop)
  41 #endif
  42
  43 #include <malloc.h>
  44 #include "registrywnt.hxx"
  45 #include "registryvalueimpl.hxx"
  46 #include "registryexception.hxx"
  47
  48 #include <assert.h>
  49
  50 #ifdef _MSC_VER
  51 #pragma warning(disable : 4786 4350)
  52 #endif
  53
  54 //---------------------------------------
  55 //
  56 //---------------------------------------
  57
  58 const size_t MAX_TMP_BUFF_SIZE = 1024 * sizeof(wchar_t);
  59
  60
  61 //############################################
  62 // Creation
  63 // only possible through WindowsRegistry class
  64 //############################################
  65
  66
  67 //-----------------------------------------------------
  68 /** Create instance and open the specified Registry key
  69 */
  70 RegistryKeyImplWinNT::RegistryKeyImplWinNT(HKEY RootKey, const std::wstring& KeyName) :
  71     RegistryKeyImpl(RootKey, KeyName)
  72 {
  73 }
  74
  75 //-----------------------------------------------------
  76 /** Create instance and open the specified Registry key
  77 */
  78 RegistryKeyImplWinNT::RegistryKeyImplWinNT(HKEY RootKey) :
  79     RegistryKeyImpl(RootKey)
  80 {
  81 }
  82
  83 //-----------------------------------------------------
  84 /** Create an instances of the specified Registry key,
  85     the key is assumed to be already opened.
  86 */
  87 RegistryKeyImplWinNT::RegistryKeyImplWinNT(HKEY RootKey, HKEY SubKey, const std::wstring& KeyName, bool Writeable) :
  88     RegistryKeyImpl(RootKey, SubKey, KeyName, Writeable)
  89 {
  90 }
  91
  92
  93 //############################################
  94 // Queries
  95 //############################################
  96
  97
  98 //-----------------------------------------------------
  99 /** The number of sub values of the key at hand
 100
 101     @precond IsOpen = true
 102
 103     @throws
 104 */
 105 size_t RegistryKeyImplWinNT::GetSubValueCount() const
 106 {
 107     assert(IsOpen());
 108
 109     DWORD nSubValues = 0;
 110
 111     LONG rc = RegQueryInfoKeyW(
 112         m_hSubKey,
 113         0, 0, 0, 0, 0, 0, &nSubValues, 0, 0, 0, 0);
 114
 115     if (ERROR_INVALID_HANDLE == rc)
 116         throw RegistryIOException(rc);
 117     else if (ERROR_SUCCESS != rc)
 118         throw RegistryException(rc);
 119
 120     return nSubValues;
 121 }
 122
 123 //-----------------------------------------------------
 124 /** The number of sub-keys of the key at hand
 125
 126     @precond IsOpen = true
 127
 128     @throws
 129 */
 130 size_t RegistryKeyImplWinNT::GetSubKeyCount() const
 131 {
 132     assert(IsOpen());
 133
 134     DWORD nSubKeys = 0;
 135
 136     LONG rc = RegQueryInfoKeyA(
 137         m_hSubKey,
 138         0, 0, 0, &nSubKeys, 0, 0, 0, 0, 0, 0, 0);
 139
 140     if (ERROR_INVALID_HANDLE == rc)
 141         throw RegistryIOException(rc);
 142     else if (ERROR_SUCCESS != rc)
 143         throw RegistryException(rc);
 144
 145     return nSubKeys;
 146 }
 147
 148 //-----------------------------------------------------
 149 /**
 150 */
 151 StringListPtr RegistryKeyImplWinNT::GetSubKeyNames() const
 152 {
 153     assert(IsOpen());
 154
 155     wchar_t buff[1024];
 156     DWORD  buff_size = sizeof(buff);
 157     FILETIME ftime;
 158
 159     StringList* key_names = new StringList();
 160
 161     LONG rc = ERROR_SUCCESS;
 162
 163     for (DWORD i = 0; /* left empty */; i++)
 164     {
 165         rc = RegEnumKeyExW(
 166             m_hSubKey, i, buff, &buff_size,
 167             0, 0, 0, &ftime);
 168
 169         if (ERROR_SUCCESS != rc &&
 170             ERROR_MORE_DATA != rc)
 171             break;
 172
 173         buff_size = sizeof(buff);
 174
 175         key_names->push_back(buff);
 176     }
 177
 178     if (ERROR_INVALID_HANDLE == rc)
 179         throw RegistryIOException(rc);
 180     else if (ERROR_NO_MORE_ITEMS != rc && ERROR_SUCCESS != rc)
 181         throw RegistryException(rc);
 182
 183 #if (_MSC_VER < 1300) && !defined(__MINGW32__)
 184     return key_names;
 185 #else
 186     return (StringListPtr) key_names;
 187 #endif
 188 }
 189
 190 //-----------------------------------------------------
 191 /**
 192 */
 193 StringListPtr RegistryKeyImplWinNT::GetSubValueNames() const
 194 {
 195     assert(IsOpen());
 196
 197     wchar_t buff[1024];
 198     DWORD  buff_size = sizeof(buff);
 199
 200     StringList* value_names = new StringList();
 201
 202     LONG rc = ERROR_SUCCESS;
 203
 204     for (DWORD i = 0; /* left empty */; i++)
 205     {
 206         rc = RegEnumValueW(
 207             m_hSubKey, i, buff, &buff_size,
 208             0, 0, 0, 0);
 209
 210         if (ERROR_SUCCESS != rc &&
 211             ERROR_MORE_DATA != rc)
 212             break;
 213
 214         buff_size = sizeof(buff);
 215
 216         value_names->push_back(buff);
 217     }
 218
 219     if (ERROR_INVALID_HANDLE == rc)
 220         throw RegistryIOException(rc);
 221     else if (ERROR_NO_MORE_ITEMS != rc && ERROR_SUCCESS != rc)
 222         throw RegistryException(rc);
 223
 224 #if (_MSC_VER < 1300) && !defined(__MINGW32__)
 225     return value_names;
 226 #else
 227     return (StringListPtr) value_names;
 228 #endif
 229 }
 230
 231 //-----------------------------------------------------
 232 /** Get the specified registry value
 233
 234     @precond IsOpen = true
 235 */
 236 RegistryValue RegistryKeyImplWinNT::GetValue(const std::wstring& Name) const
 237 {
 238     assert(IsOpen());
 239
 240     DWORD Type;
 241     wchar_t buff[MAX_TMP_BUFF_SIZE];
 242     DWORD   size = sizeof(buff);
 243
 244     LONG rc = RegQueryValueExW(
 245         m_hSubKey,
 246         Name.c_str(),
 247         0,
 248         &Type,
 249         reinterpret_cast<LPBYTE>(buff),
 250         &size);
 251
 252     if (ERROR_FILE_NOT_FOUND == rc)
 253         throw RegistryValueNotFoundException(rc);
 254     else if (ERROR_ACCESS_DENIED == rc)
 255         throw RegistryAccessDeniedException(rc);
 256     else if (ERROR_SUCCESS != rc)
 257         throw RegistryException(rc);
 258
 259     RegistryValue regval;
 260
 261     if (REG_DWORD == Type)
 262     {
 263         regval = RegistryValue(new RegistryValueImpl(Name, *(reinterpret_cast<int*>(buff))));
 264     }
 265     else if (REG_SZ == Type || REG_EXPAND_SZ == Type || REG_MULTI_SZ == Type)
 266     {
 267         if (size > 0)
 268             regval = RegistryValue(new RegistryValueImpl(Name, std::wstring(reinterpret_cast<wchar_t*>(buff))));
 269         else
 270             regval = RegistryValue(new RegistryValueImpl(Name, std::wstring()));
 271     }
 272     else
 273     {
 274         assert(false);
 275     }
 276
 277     return regval;
 278 }
 279
 280 //-----------------------------------------------------
 281 /** Get the specified registry value, return the given
 282     default value if value not found
 283
 284     @precond IsOpen = true
 285 */
 286 RegistryValue RegistryKeyImplWinNT::GetValue(const std::wstring& Name, const RegistryValue& Default) const
 287 {
 288     assert(IsOpen());
 289
 290     DWORD Type;
 291     wchar_t buff[MAX_TMP_BUFF_SIZE];
 292     DWORD   size = sizeof(buff);
 293
 294     LONG rc = RegQueryValueExW(
 295         m_hSubKey,
 296         Name.c_str(),
 297         0,
 298         &Type,
 299         reinterpret_cast<LPBYTE>(buff),
 300         &size);
 301
 302     if (ERROR_FILE_NOT_FOUND == rc)
 303     {
 304         #if (_MSC_VER < 1300) && !defined(__MINGW32__)
 305         return Default;
 306         #else
 307         RegistryValue regval_ptr;
 308         regval_ptr = RegistryValue(new RegistryValueImpl(*Default));
 309         return regval_ptr;
 310         #endif
 311     }
 312
 313     if (ERROR_ACCESS_DENIED == rc)
 314         throw RegistryAccessDeniedException(rc);
 315     else if (ERROR_SUCCESS != rc)
 316         throw RegistryException(rc);
 317
 318     RegistryValue regval;
 319
 320     if (REG_DWORD == Type)
 321         regval = RegistryValue(new RegistryValueImpl(Name, *reinterpret_cast<int*>(buff)));
 322     else if (REG_SZ == Type || REG_EXPAND_SZ == Type || REG_MULTI_SZ == Type)
 323         regval = RegistryValue(new RegistryValueImpl(Name, std::wstring(reinterpret_cast<wchar_t*>(buff))));
 324     else
 325         assert(false);
 326
 327     return regval;
 328 }
 329
 330
 331 //############################################
 332 // Commands
 333 //############################################
 334
 335
 336 //-----------------------------------------------------
 337 /** Open the registry key, has no effect if
 338     the key is already open
 339
 340     @precond IsOpen = false
 341
 342     @throws RegistryKeyNotFoundException
 343             RegistryWriteAccessDenyException
 344             RegistryAccessDenyException
 345 */
 346 void RegistryKeyImplWinNT::Open(bool Writeable)
 347 {
 348     assert(!IsOpen());
 349
 350     REGSAM regsam = KEY_READ;
 351
 352     if (Writeable)
 353         regsam |= KEY_WRITE;
 354
 355     LONG rc = RegOpenKeyExW(
 356         m_hRootKey,
 357         m_KeyName.c_str(),
 358         0,
 359         regsam,
 360         &m_hSubKey);
 361
 362     if (ERROR_FILE_NOT_FOUND == rc)
 363         throw RegistryKeyNotFoundException(rc);
 364     else if (ERROR_ACCESS_DENIED == rc)
 365         throw RegistryAccessDeniedException(rc);
 366     else if (ERROR_SUCCESS != rc)
 367         throw RegistryException(rc);
 368
 369     m_IsWriteable = Writeable;
 370
 371     assert(IsOpen());
 372 }
 373
 374 //-----------------------------------------------------
 375 /** Open the specified sub-key of the registry key
 376     at hand
 377
 378     @precond IsOpen = true
 379              HasSubKey(Name) = true
 380
 381     @throws RegistryIOException
 382             RegistryKeyNotFoundException
 383             RegistryAccessDeniedException
 384 */
 385 RegistryKey RegistryKeyImplWinNT::OpenSubKey(const std::wstring& Name, bool Writeable)
 386 {
 387     RegistryKey regkey(new RegistryKeyImplWinNT(m_hSubKey, Name));
 388     regkey->Open(Writeable);
 389     return regkey;
 390 }
 391
 392 //-----------------------------------------------------
 393 /** Creates a new sub-key below the key at hand
 394
 395     @precond IsOpen = true
 396              IsWriteable = true
 397
 398     @throws  RegistryIOException
 399              RegistryWriteAccessDenyException
 400 */
 401
 402 RegistryKey RegistryKeyImplWinNT::CreateSubKey(const std::wstring& Name)
 403 {
 404     assert(IsOpen());
 405     assert(IsWriteable());
 406
 407     HKEY hRoot = IsRootKey() ? m_hRootKey : m_hSubKey;
 408
 409     HKEY hKey;
 410
 411     LONG rc = RegCreateKeyExW(
 412         hRoot,
 413         Name.c_str(),
 414         0,
 415         0,
 416         REG_OPTION_NON_VOLATILE,
 417         KEY_READ | KEY_WRITE,
 418         0,
 419         &hKey,
 420         0);
 421
 422     if (ERROR_INVALID_HANDLE == rc)
 423         throw RegistryIOException(rc);
 424     else if (ERROR_ACCESS_DENIED == rc)
 425         throw RegistryAccessDeniedException(rc);
 426     else if (ERROR_SUCCESS != rc)
 427         throw RegistryException(rc);
 428
 429     return RegistryKey(new RegistryKeyImplWinNT(hRoot, hKey, Name));
 430 }
 431
 432 //-----------------------------------------------------
 433 /** Deletes a sub-key below the key at hand, the
 434     key must not have sub-keys
 435
 436     @precond IsOpen = true
 437              IsWriteable = true
 438
 439     @throws  RegistryIOException
 440              RegistryWriteAccessDenyException
 441 */
 442 void RegistryKeyImplWinNT::DeleteSubKey(const std::wstring& Name)
 443 {
 444     assert(IsOpen());
 445     assert(IsWriteable());
 446     assert(HasSubKey(Name));
 447
 448     RegistryKey SubKey = OpenSubKey(Name);
 449
 450     size_t nSubKeyCount = SubKey->GetSubKeyCount();
 451
 452     assert(0 == nSubKeyCount);
 453
 454     if (nSubKeyCount)
 455         throw RegistryInvalidOperationException(ERROR_NOT_SUPPORTED);
 456
 457     LONG rc = RegDeleteKeyW(m_hSubKey, Name.c_str());
 458
 459     if (ERROR_INVALID_HANDLE == rc)
 460         throw RegistryIOException(rc);
 461     else if (ERROR_ACCESS_DENIED == rc)
 462         throw RegistryAccessDeniedException(rc);
 463     else if (ERROR_SUCCESS != rc)
 464         throw RegistryException(rc);
 465 }
 466
 467 //-----------------------------------------------------
 468 /** Deletes a sub-key below the key at hand with all
 469     its sub-keys
 470
 471     @precond IsOpen = true
 472              IsWriteable = true;
 473
 474     @throws  RegistryIOException
 475              RegistryWriteAccessDenyException
 476 */
 477 void RegistryKeyImplWinNT::DeleteSubKeyTree(const std::wstring& Name)
 478 {
 479     ImplDeleteSubKeyTree(m_hSubKey, Name);
 480 }
 481
 482 //-----------------------------------------------------
 483 /** Deletes a sub-key below the key at hand with all
 484     its sub-keys
 485
 486     @precond IsOpen = true
 487              IsWriteable = true;
 488
 489     @throws  RegistryIOException
 490              RegistryWriteAccessDenyException
 491 */
 492 LONG RegistryKeyImplWinNT::ImplDeleteSubKeyTree(HKEY RootKey, const std::wstring& Name)
 493 {
 494     assert(IsOpen());
 495
 496     HKEY hKey;
 497
 498     LONG rc = RegOpenKeyExW(
 499         RootKey,
 500         Name.c_str(),
 501         0,
 502         KEY_READ | DELETE,
 503         &hKey);
 504
 505     if (ERROR_SUCCESS == rc)
 506     {
 507         wchar_t* lpSubKey;
 508         DWORD    nMaxSubKeyLen;
 509
 510         rc = RegQueryInfoKeyW(
 511             hKey, 0, 0, 0, 0,
 512             &nMaxSubKeyLen,
 513             0, 0, 0, 0, 0, 0);
 514
 515         nMaxSubKeyLen++; // space for trailing '\0'
 516
 517         lpSubKey = reinterpret_cast<wchar_t*>(
 518             _alloca(nMaxSubKeyLen*sizeof(wchar_t)));
 519
 520         while (ERROR_SUCCESS == rc)
 521         {
 522             DWORD nLen = nMaxSubKeyLen;
 523
 524             rc = RegEnumKeyExW(
 525                 hKey,
 526                 0,       // always index zero
 527                 lpSubKey,
 528                 &nLen,
 529                 0, 0, 0, 0);
 530
 531             if (ERROR_NO_MORE_ITEMS == rc)
 532             {
 533                 rc = RegDeleteKeyW(RootKey, Name.c_str());
 534                 break;
 535             }
 536             else if (rc == ERROR_SUCCESS)
 537             {
 538                 rc = ImplDeleteSubKeyTree(hKey, lpSubKey);
 539             }
 540
 541         } // while
 542
 543         RegCloseKey(hKey);
 544
 545     } // if
 546
 547     if (ERROR_INVALID_HANDLE == rc)
 548         throw RegistryIOException(rc);
 549     else if (ERROR_ACCESS_DENIED == rc)
 550         throw RegistryAccessDeniedException(rc);
 551     else if (ERROR_FILE_NOT_FOUND == rc)
 552         throw RegistryKeyNotFoundException(rc);
 553     else if (ERROR_SUCCESS != rc)
 554         throw RegistryException(rc);
 555
 556     return rc;
 557 }
 558
 559 //-----------------------------------------------------
 560 /** Delete the specified value
 561
 562         @precond IsOpen = true
 563                  IsWriteable = true
 564                  HasValue(Name) = true
 565
 566         @throws RegistryIOException
 567                 RegistryWriteAccessDeniedException
 568                 RegistryValueNotFoundException
 569 */
 570 void RegistryKeyImplWinNT::DeleteValue(const std::wstring& Name)
 571 {
 572     assert(IsOpen());
 573     assert(HasValue(Name));
 574     assert(IsWriteable());
 575
 576     LONG rc = RegDeleteValueW(
 577         m_hSubKey,
 578         Name.c_str());
 579
 580     if (ERROR_INVALID_HANDLE == rc)
 581         throw RegistryIOException(rc);
 582     else if (ERROR_ACCESS_DENIED == rc)
 583         throw RegistryNoWriteAccessException(rc);
 584     else if (ERROR_FILE_NOT_FOUND == rc)
 585         throw RegistryValueNotFoundException(rc);
 586     else if (ERROR_SUCCESS != rc)
 587         throw RegistryException(rc);
 588 }
 589
 590 //-----------------------------------------------------
 591 /** Set the specified registry value
 592
 593     @precond IsOpen = true
 594              IsWriteable = true
 595
 596     @throws  RegistryIOException
 597              RegistryWriteAccessDenyException
 598 */
 599 void RegistryKeyImplWinNT::SetValue(const RegistryValue& Value)
 600 {
 601     assert(IsOpen());
 602     assert(IsWriteable());
 603
 604     LONG rc = RegSetValueExW(
 605         m_hSubKey,
 606         Value->GetName().c_str(),
 607         0,
 608         Value->GetType(),
 609         reinterpret_cast<const unsigned char*>(Value->GetDataBuffer()),
 610         static_cast<DWORD>(Value->GetDataSize()));
 611
 612     if (ERROR_INVALID_HANDLE == rc)
 613         throw RegistryIOException(rc);
 614     else if (ERROR_ACCESS_DENIED == rc)
 615         throw RegistryAccessDeniedException(rc);
 616     else if (ERROR_SUCCESS != rc)
 617         throw RegistryException(rc);
 618 }
 619
 620
 621
 622