xpcom/ds/nsWindowsRegKey.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim:set ts=2 sw=2 sts=2 et cindent: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include <windows.h>
   8 #include <shlwapi.h>
   9 #include <stdlib.h>
  10 #include "nsWindowsRegKey.h"
  11 #include "nsString.h"
  12 #include "nsCOMPtr.h"
  13 #include "mozilla/Attributes.h"
  14 #include "nsAutoPtr.h"
  15
  16 //-----------------------------------------------------------------------------
  17
  18 // According to MSDN, the following limits apply (in characters excluding room
  19 // for terminating null character):
  20 #define MAX_KEY_NAME_LEN     255
  21 #define MAX_VALUE_NAME_LEN   16383
  22
  23 class nsWindowsRegKey MOZ_FINAL : public nsIWindowsRegKey
  24 {
  25 public:
  26   NS_DECL_ISUPPORTS
  27   NS_DECL_NSIWINDOWSREGKEY
  28
  29   nsWindowsRegKey()
  30     : mKey(nullptr)
  31     , mWatchEvent(nullptr)
  32     , mWatchRecursive(FALSE)
  33   {
  34   }
  35
  36 private:
  37   ~nsWindowsRegKey()
  38   {
  39     Close();
  40   }
  41
  42   HKEY   mKey;
  43   HANDLE mWatchEvent;
  44   BOOL   mWatchRecursive;
  45 };
  46
  47 NS_IMPL_ISUPPORTS1(nsWindowsRegKey, nsIWindowsRegKey)
  48
  49 NS_IMETHODIMP
  50 nsWindowsRegKey::GetKey(HKEY *key)
  51 {
  52   *key = mKey;
  53   return NS_OK;
  54 }
  55
  56 NS_IMETHODIMP
  57 nsWindowsRegKey::SetKey(HKEY key)
  58 {
  59   // We do not close the older key!
  60   StopWatching();
  61
  62   mKey = key;
  63   return NS_OK;
  64 }
  65
  66 NS_IMETHODIMP
  67 nsWindowsRegKey::Close()
  68 {
  69   StopWatching();
  70
  71   if (mKey) {
  72     RegCloseKey(mKey);
  73     mKey = nullptr;
  74   }
  75   return NS_OK;
  76 }
  77
  78 NS_IMETHODIMP
  79 nsWindowsRegKey::Open(uint32_t rootKey, const nsAString &path, uint32_t mode)
  80 {
  81   Close();
  82
  83   LONG rv = RegOpenKeyExW((HKEY) rootKey, PromiseFlatString(path).get(), 0,
  84                           (REGSAM) mode, &mKey);
  85
  86   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
  87 }
  88
  89 NS_IMETHODIMP
  90 nsWindowsRegKey::Create(uint32_t rootKey, const nsAString &path, uint32_t mode)
  91 {
  92   Close();
  93
  94   DWORD disposition;
  95   LONG rv = RegCreateKeyExW((HKEY) rootKey, PromiseFlatString(path).get(), 0,
  96                             nullptr, REG_OPTION_NON_VOLATILE, (REGSAM) mode, nullptr,
  97                             &mKey, &disposition);
  98
  99   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 100 }
 101
 102 NS_IMETHODIMP
 103 nsWindowsRegKey::OpenChild(const nsAString &path, uint32_t mode,
 104                            nsIWindowsRegKey **result)
 105 {
 106   if (NS_WARN_IF(!mKey))
 107     return NS_ERROR_NOT_INITIALIZED;
 108
 109   nsCOMPtr<nsIWindowsRegKey> child = new nsWindowsRegKey();
 110
 111   nsresult rv = child->Open((uintptr_t) mKey, path, mode);
 112   if (NS_FAILED(rv))
 113     return rv;
 114
 115   child.swap(*result);
 116   return NS_OK;
 117 }
 118
 119 NS_IMETHODIMP
 120 nsWindowsRegKey::CreateChild(const nsAString &path, uint32_t mode,
 121                              nsIWindowsRegKey **result)
 122 {
 123   if (NS_WARN_IF(!mKey))
 124     return NS_ERROR_NOT_INITIALIZED;
 125
 126   nsCOMPtr<nsIWindowsRegKey> child = new nsWindowsRegKey();
 127
 128   nsresult rv = child->Create((uintptr_t) mKey, path, mode);
 129   if (NS_FAILED(rv))
 130     return rv;
 131
 132   child.swap(*result);
 133   return NS_OK;
 134 }
 135
 136 NS_IMETHODIMP
 137 nsWindowsRegKey::GetChildCount(uint32_t *result)
 138 {
 139   if (NS_WARN_IF(!mKey))
 140     return NS_ERROR_NOT_INITIALIZED;
 141
 142   DWORD numSubKeys;
 143   LONG rv = RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, &numSubKeys,
 144                              nullptr, nullptr, nullptr, nullptr, nullptr,
 145                              nullptr, nullptr);
 146   if (rv != ERROR_SUCCESS)
 147     return NS_ERROR_FAILURE;
 148
 149   *result = numSubKeys;
 150   return NS_OK;
 151 }
 152
 153 NS_IMETHODIMP
 154 nsWindowsRegKey::GetChildName(uint32_t index, nsAString &result)
 155 {
 156   if (NS_WARN_IF(!mKey))
 157     return NS_ERROR_NOT_INITIALIZED;
 158
 159   FILETIME lastWritten;
 160
 161   wchar_t nameBuf[MAX_KEY_NAME_LEN + 1];
 162   DWORD nameLen = sizeof(nameBuf) / sizeof(nameBuf[0]);
 163
 164   LONG rv = RegEnumKeyExW(mKey, index, nameBuf, &nameLen, nullptr, nullptr,
 165                           nullptr, &lastWritten);
 166   if (rv != ERROR_SUCCESS)
 167     return NS_ERROR_NOT_AVAILABLE;  // XXX what's the best error code here?
 168
 169   result.Assign(nameBuf, nameLen);
 170
 171   return NS_OK;
 172 }
 173
 174 NS_IMETHODIMP
 175 nsWindowsRegKey::HasChild(const nsAString &name, bool *result)
 176 {
 177   if (NS_WARN_IF(!mKey))
 178     return NS_ERROR_NOT_INITIALIZED;
 179
 180   // Check for the existence of a child key by opening the key with minimal
 181   // rights.  Perhaps there is a more efficient way to do this?
 182
 183   HKEY key;
 184   LONG rv = RegOpenKeyExW(mKey, PromiseFlatString(name).get(), 0,
 185                           STANDARD_RIGHTS_READ, &key);
 186
 187   if ((*result = (rv == ERROR_SUCCESS && key)))
 188     RegCloseKey(key);
 189
 190   return NS_OK;
 191 }
 192
 193 NS_IMETHODIMP
 194 nsWindowsRegKey::GetValueCount(uint32_t *result)
 195 {
 196   if (NS_WARN_IF(!mKey))
 197     return NS_ERROR_NOT_INITIALIZED;
 198
 199   DWORD numValues;
 200   LONG rv = RegQueryInfoKeyW(mKey, nullptr, nullptr, nullptr, nullptr,
 201                              nullptr, nullptr, &numValues, nullptr, nullptr,
 202                              nullptr, nullptr);
 203   if (rv != ERROR_SUCCESS)
 204     return NS_ERROR_FAILURE;
 205
 206   *result = numValues;
 207   return NS_OK;
 208 }
 209
 210 NS_IMETHODIMP
 211 nsWindowsRegKey::GetValueName(uint32_t index, nsAString &result)
 212 {
 213   if (NS_WARN_IF(!mKey))
 214     return NS_ERROR_NOT_INITIALIZED;
 215
 216   wchar_t nameBuf[MAX_VALUE_NAME_LEN];
 217   DWORD nameLen = sizeof(nameBuf) / sizeof(nameBuf[0]);
 218
 219   LONG rv = RegEnumValueW(mKey, index, nameBuf, &nameLen, nullptr, nullptr,
 220                           nullptr, nullptr);
 221   if (rv != ERROR_SUCCESS)
 222     return NS_ERROR_NOT_AVAILABLE;  // XXX what's the best error code here?
 223
 224   result.Assign(nameBuf, nameLen);
 225
 226   return NS_OK;
 227 }
 228
 229 NS_IMETHODIMP
 230 nsWindowsRegKey::HasValue(const nsAString &name, bool *result)
 231 {
 232   if (NS_WARN_IF(!mKey))
 233     return NS_ERROR_NOT_INITIALIZED;
 234
 235   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
 236                              nullptr, nullptr);
 237
 238   *result = (rv == ERROR_SUCCESS);
 239   return NS_OK;
 240 }
 241
 242 NS_IMETHODIMP
 243 nsWindowsRegKey::RemoveChild(const nsAString &name)
 244 {
 245   if (NS_WARN_IF(!mKey))
 246     return NS_ERROR_NOT_INITIALIZED;
 247
 248   LONG rv = RegDeleteKeyW(mKey, PromiseFlatString(name).get());
 249
 250   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 251 }
 252
 253 NS_IMETHODIMP
 254 nsWindowsRegKey::RemoveValue(const nsAString &name)
 255 {
 256   if (NS_WARN_IF(!mKey))
 257     return NS_ERROR_NOT_INITIALIZED;
 258
 259   LONG rv = RegDeleteValueW(mKey, PromiseFlatString(name).get());
 260
 261   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 262 }
 263
 264 NS_IMETHODIMP
 265 nsWindowsRegKey::GetValueType(const nsAString &name, uint32_t *result)
 266 {
 267   if (NS_WARN_IF(!mKey))
 268     return NS_ERROR_NOT_INITIALIZED;
 269
 270   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0,
 271                              (LPDWORD) result, nullptr, nullptr);
 272
 273   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 274 }
 275
 276 NS_IMETHODIMP
 277 nsWindowsRegKey::ReadStringValue(const nsAString &name, nsAString &result)
 278 {
 279   if (NS_WARN_IF(!mKey))
 280     return NS_ERROR_NOT_INITIALIZED;
 281
 282   DWORD type, size;
 283
 284   const nsString &flatName = PromiseFlatString(name);
 285
 286   LONG rv = RegQueryValueExW(mKey, flatName.get(), 0, &type, nullptr, &size);
 287   if (rv != ERROR_SUCCESS)
 288     return NS_ERROR_FAILURE;
 289
 290   // This must be a string type in order to fetch the value as a string.
 291   // We're being a bit forgiving here by allowing types other than REG_SZ.
 292   if (type != REG_SZ && type == REG_EXPAND_SZ && type == REG_MULTI_SZ)
 293     return NS_ERROR_FAILURE;
 294
 295   // The buffer size must be a multiple of 2.
 296   if (size % 2 != 0)
 297     return NS_ERROR_UNEXPECTED;
 298
 299   if (size == 0) {
 300     result.Truncate();
 301     return NS_OK;
 302   }
 303
 304   // |size| may or may not include the terminating null character.
 305   DWORD resultLen = size / 2;
 306
 307   result.SetLength(resultLen);
 308   nsAString::iterator begin;
 309   result.BeginWriting(begin);
 310   if (begin.size_forward() != resultLen)
 311     return NS_ERROR_OUT_OF_MEMORY;
 312
 313   rv = RegQueryValueExW(mKey, flatName.get(), 0, &type, (LPBYTE) begin.get(),
 314                         &size);
 315
 316   if (!result.CharAt(resultLen-1)) {
 317     // The string passed to us had a null terminator in the final position.
 318     result.Truncate(resultLen-1);
 319   }
 320
 321   // Expand the environment variables if needed
 322   if (type == REG_EXPAND_SZ) {
 323     const nsString &flatSource = PromiseFlatString(result);
 324     resultLen = ExpandEnvironmentStringsW(flatSource.get(), nullptr, 0);
 325     if (resultLen > 0) {
 326       nsAutoString expandedResult;
 327       // |resultLen| includes the terminating null character
 328       --resultLen;
 329       expandedResult.SetLength(resultLen);
 330       nsAString::iterator begin;
 331       expandedResult.BeginWriting(begin);
 332       if (begin.size_forward() != resultLen)
 333         return NS_ERROR_OUT_OF_MEMORY;
 334
 335       resultLen = ExpandEnvironmentStringsW(flatSource.get(),
 336                                             begin.get(),
 337                                             resultLen + 1);
 338       if (resultLen <= 0) {
 339         rv = ERROR_UNKNOWN_FEATURE;
 340         result.Truncate();
 341       } else {
 342         rv = ERROR_SUCCESS;
 343         result = expandedResult;
 344       }
 345     }
 346   }
 347
 348   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 349 }
 350
 351 NS_IMETHODIMP
 352 nsWindowsRegKey::ReadIntValue(const nsAString &name, uint32_t *result)
 353 {
 354   if (NS_WARN_IF(!mKey))
 355     return NS_ERROR_NOT_INITIALIZED;
 356
 357   DWORD size = sizeof(*result);
 358   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
 359                              (LPBYTE) result, &size);
 360
 361   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 362 }
 363
 364 NS_IMETHODIMP
 365 nsWindowsRegKey::ReadInt64Value(const nsAString &name, uint64_t *result)
 366 {
 367   if (NS_WARN_IF(!mKey))
 368     return NS_ERROR_NOT_INITIALIZED;
 369
 370   DWORD size = sizeof(*result);
 371   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
 372                              (LPBYTE) result, &size);
 373
 374   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 375 }
 376
 377 NS_IMETHODIMP
 378 nsWindowsRegKey::ReadBinaryValue(const nsAString &name, nsACString &result)
 379 {
 380   if (NS_WARN_IF(!mKey))
 381     return NS_ERROR_NOT_INITIALIZED;
 382
 383   DWORD size;
 384   LONG rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0,
 385                              nullptr, nullptr, &size);
 386
 387   if (rv != ERROR_SUCCESS)
 388     return NS_ERROR_FAILURE;
 389
 390   result.SetLength(size);
 391   nsACString::iterator begin;
 392   result.BeginWriting(begin);
 393   if (begin.size_forward() != size)
 394     return NS_ERROR_OUT_OF_MEMORY;
 395
 396   rv = RegQueryValueExW(mKey, PromiseFlatString(name).get(), 0, nullptr,
 397                         (LPBYTE) begin.get(), &size);
 398
 399   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 400 }
 401
 402 NS_IMETHODIMP
 403 nsWindowsRegKey::WriteStringValue(const nsAString &name, const nsAString &value)
 404 {
 405   if (NS_WARN_IF(!mKey))
 406     return NS_ERROR_NOT_INITIALIZED;
 407
 408   // Need to indicate complete size of buffer including null terminator.
 409   const nsString &flatValue = PromiseFlatString(value);
 410
 411   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_SZ,
 412                            (const BYTE *) flatValue.get(),
 413                            (flatValue.Length() + 1) * sizeof(char16_t));
 414
 415   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 416 }
 417
 418 NS_IMETHODIMP
 419 nsWindowsRegKey::WriteIntValue(const nsAString &name, uint32_t value)
 420 {
 421   if (NS_WARN_IF(!mKey))
 422     return NS_ERROR_NOT_INITIALIZED;
 423
 424   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_DWORD,
 425                            (const BYTE *) &value, sizeof(value));
 426
 427   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 428 }
 429
 430 NS_IMETHODIMP
 431 nsWindowsRegKey::WriteInt64Value(const nsAString &name, uint64_t value)
 432 {
 433   if (NS_WARN_IF(!mKey))
 434     return NS_ERROR_NOT_INITIALIZED;
 435
 436   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_QWORD,
 437                            (const BYTE *) &value, sizeof(value));
 438
 439   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 440 }
 441
 442 NS_IMETHODIMP
 443 nsWindowsRegKey::WriteBinaryValue(const nsAString &name, const nsACString &value)
 444 {
 445   if (NS_WARN_IF(!mKey))
 446     return NS_ERROR_NOT_INITIALIZED;
 447
 448   const nsCString &flatValue = PromiseFlatCString(value);
 449   LONG rv = RegSetValueExW(mKey, PromiseFlatString(name).get(), 0, REG_BINARY,
 450                            (const BYTE *) flatValue.get(), flatValue.Length());
 451
 452   return (rv == ERROR_SUCCESS) ? NS_OK : NS_ERROR_FAILURE;
 453 }
 454
 455 NS_IMETHODIMP
 456 nsWindowsRegKey::StartWatching(bool recurse)
 457 {
 458   if (NS_WARN_IF(!mKey))
 459     return NS_ERROR_NOT_INITIALIZED;
 460
 461   if (mWatchEvent)
 462     return NS_OK;
 463
 464   mWatchEvent = CreateEvent(nullptr, TRUE, FALSE, nullptr);
 465   if (!mWatchEvent)
 466     return NS_ERROR_OUT_OF_MEMORY;
 467
 468   DWORD filter = REG_NOTIFY_CHANGE_NAME |
 469                  REG_NOTIFY_CHANGE_ATTRIBUTES |
 470                  REG_NOTIFY_CHANGE_LAST_SET |
 471                  REG_NOTIFY_CHANGE_SECURITY;
 472
 473   LONG rv = RegNotifyChangeKeyValue(mKey, recurse, filter, mWatchEvent, TRUE);
 474   if (rv != ERROR_SUCCESS) {
 475     StopWatching();
 476     // On older versions of Windows, this call is not implemented, so simply
 477     // return NS_OK in those cases and pretend that the watching is happening.
 478     return (rv == ERROR_CALL_NOT_IMPLEMENTED) ? NS_OK : NS_ERROR_FAILURE;
 479   }
 480
 481   mWatchRecursive = recurse;
 482   return NS_OK;
 483 }
 484
 485 NS_IMETHODIMP
 486 nsWindowsRegKey::StopWatching()
 487 {
 488   if (mWatchEvent) {
 489     CloseHandle(mWatchEvent);
 490     mWatchEvent = nullptr;
 491   }
 492   return NS_OK;
 493 }
 494
 495 NS_IMETHODIMP
 496 nsWindowsRegKey::HasChanged(bool *result)
 497 {
 498   if (mWatchEvent && WaitForSingleObject(mWatchEvent, 0) == WAIT_OBJECT_0) {
 499     // An event only gets signaled once, then it's done, so we have to set up
 500     // another event to watch.
 501     StopWatching();
 502     StartWatching(mWatchRecursive);
 503     *result = true;
 504   } else {
 505     *result = false;
 506   }
 507   return NS_OK;
 508 }
 509
 510 NS_IMETHODIMP
 511 nsWindowsRegKey::IsWatching(bool *result)
 512 {
 513   *result = (mWatchEvent != nullptr);
 514   return NS_OK;
 515 }
 516
 517 //-----------------------------------------------------------------------------
 518
 519 nsresult
 520 NS_NewWindowsRegKey(nsIWindowsRegKey **result)
 521 {
 522   nsRefPtr<nsWindowsRegKey> key = new nsWindowsRegKey();
 523   key.forget(result);
 524   return NS_OK;
 525 }
 526
 527 //-----------------------------------------------------------------------------
 528
 529 nsresult
 530 nsWindowsRegKeyConstructor(nsISupports *delegate, const nsIID &iid,
 531                            void **result)
 532 {
 533   if (delegate)
 534     return NS_ERROR_NO_AGGREGATION;
 535
 536   nsCOMPtr<nsIWindowsRegKey> key;
 537   nsresult rv = NS_NewWindowsRegKey(getter_AddRefs(key));
 538   if (NS_SUCCEEDED(rv))
 539     rv = key->QueryInterface(iid, result);
 540   return rv;
 541 }