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

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