Home | History | Annotate | Download | only in lib 
      1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "rlz/win/lib/rlz_value_store_registry.h"
      6 
      7 #include "base/strings/stringprintf.h"
      8 #include "base/strings/utf_string_conversions.h"
      9 #include "base/win/registry.h"
     10 #include "rlz/lib/assert.h"
     11 #include "rlz/lib/lib_values.h"
     12 #include "rlz/lib/rlz_lib.h"
     13 #include "rlz/lib/string_utils.h"
     14 #include "rlz/win/lib/registry_util.h"
     15 
     16 using base::ASCIIToWide;
     17 
     18 namespace rlz_lib {
     19 
     20 namespace {
     21 
     22 //
     23 // Registry keys:
     24 //
     25 //   RLZ's are stored as:
     26 //   <AccessPointName>  = <RLZ value> @ kRootKey\kLibKeyName\kRlzsSubkeyName.
     27 //
     28 //   Events are stored as:
     29 //   <AccessPointName><EventName> = 1 @
     30 //   HKCU\kLibKeyName\kEventsSubkeyName\GetProductName(product).
     31 //
     32 //   The OEM Deal Confirmation Code (DCC) is stored as
     33 //   kDccValueName = <DCC value> @ HKLM\kLibKeyName
     34 //
     35 //   The last ping time, per product is stored as:
     36 //   GetProductName(product) = <last ping time> @
     37 //   HKCU\kLibKeyName\kPingTimesSubkeyName.
     38 //
     39 // The server does not care about any of these constants.
     40 //
     41 const char kLibKeyName[]               = "Software\\Google\\Common\\Rlz";
     42 const wchar_t kGoogleKeyName[]         = L"Software\\Google";
     43 const wchar_t kGoogleCommonKeyName[]   = L"Software\\Google\\Common";
     44 const char kRlzsSubkeyName[]           = "RLZs";
     45 const char kEventsSubkeyName[]         = "Events";
     46 const char kStatefulEventsSubkeyName[] = "StatefulEvents";
     47 const char kPingTimesSubkeyName[]      = "PTimes";
     48 
     49 std::wstring GetWideProductName(Product product) {
     50   return ASCIIToWide(GetProductName(product));
     51 }
     52 
     53 void AppendBrandToString(std::string* str) {
     54   std::string brand(SupplementaryBranding::GetBrand());
     55   if (!brand.empty())
     56     base::StringAppendF(str, "\\_%s", brand.c_str());
     57 }
     58 
     59 // Function to get the specific registry keys.
     60 bool GetRegKey(const char* name, REGSAM access, base::win::RegKey* key) {
     61   std::string key_location;
     62   base::StringAppendF(&key_location, "%s\\%s", kLibKeyName, name);
     63   AppendBrandToString(&key_location);
     64 
     65   LONG ret = ERROR_SUCCESS;
     66   if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK)) {
     67     ret = key->Create(HKEY_CURRENT_USER, ASCIIToWide(key_location).c_str(),
     68                       access);
     69   } else {
     70     ret = key->Open(HKEY_CURRENT_USER, ASCIIToWide(key_location).c_str(),
     71                     access);
     72   }
     73 
     74   return ret == ERROR_SUCCESS;
     75 }
     76 
     77 bool GetPingTimesRegKey(REGSAM access, base::win::RegKey* key) {
     78   return GetRegKey(kPingTimesSubkeyName, access, key);
     79 }
     80 
     81 
     82 bool GetEventsRegKey(const char* event_type,
     83                      const rlz_lib::Product* product,
     84                      REGSAM access, base::win::RegKey* key) {
     85   std::string key_location;
     86   base::StringAppendF(&key_location, "%s\\%s", kLibKeyName,
     87                       event_type);
     88   AppendBrandToString(&key_location);
     89 
     90   if (product != NULL) {
     91     std::string product_name = GetProductName(*product);
     92     if (product_name.empty())
     93       return false;
     94 
     95     base::StringAppendF(&key_location, "\\%s", product_name.c_str());
     96   }
     97 
     98   LONG ret = ERROR_SUCCESS;
     99   if (access & (KEY_SET_VALUE | KEY_CREATE_SUB_KEY | KEY_CREATE_LINK)) {
    100     ret = key->Create(HKEY_CURRENT_USER, ASCIIToWide(key_location).c_str(),
    101                       access);
    102   } else {
    103     ret = key->Open(HKEY_CURRENT_USER, ASCIIToWide(key_location).c_str(),
    104                     access);
    105   }
    106 
    107   return ret == ERROR_SUCCESS;
    108 }
    109 
    110 bool GetAccessPointRlzsRegKey(REGSAM access, base::win::RegKey* key) {
    111   return GetRegKey(kRlzsSubkeyName, access, key);
    112 }
    113 
    114 bool ClearAllProductEventValues(rlz_lib::Product product, const char* key) {
    115   std::wstring product_name = GetWideProductName(product);
    116   if (product_name.empty())
    117     return false;
    118 
    119   base::win::RegKey reg_key;
    120   GetEventsRegKey(key, NULL, KEY_WRITE, &reg_key);
    121   reg_key.DeleteKey(product_name.c_str());
    122 
    123   // Verify that the value no longer exists.
    124   base::win::RegKey product_events(
    125       reg_key.Handle(), product_name.c_str(), KEY_READ);
    126   if (product_events.Valid()) {
    127     ASSERT_STRING("ClearAllProductEvents: Key deletion failed");
    128     return false;
    129   }
    130 
    131   return true;
    132 }
    133 
    134 // Deletes a registry key if it exists and has no subkeys or values.
    135 // TODO: Move this to a registry_utils file and add unittest.
    136 bool DeleteKeyIfEmpty(HKEY root_key, const wchar_t* key_name) {
    137   if (!key_name) {
    138     ASSERT_STRING("DeleteKeyIfEmpty: key_name is NULL");
    139     return false;
    140   } else {  // Scope needed for RegKey
    141     base::win::RegKey key(root_key, key_name, KEY_READ);
    142     if (!key.Valid())
    143       return true;  // Key does not exist - nothing to do.
    144 
    145     base::win::RegistryKeyIterator key_iter(root_key, key_name);
    146     if (key_iter.SubkeyCount() > 0)
    147       return true;  // Not empty, so nothing to do
    148 
    149     base::win::RegistryValueIterator value_iter(root_key, key_name);
    150     if (value_iter.ValueCount() > 0)
    151       return true;  // Not empty, so nothing to do
    152   }
    153 
    154   // The key is empty - delete it now.
    155   base::win::RegKey key(root_key, L"", KEY_WRITE);
    156   return key.DeleteKey(key_name) == ERROR_SUCCESS;
    157 }
    158 
    159 }  // namespace
    160 
    161 // static
    162 std::wstring RlzValueStoreRegistry::GetWideLibKeyName() {
    163   return ASCIIToWide(kLibKeyName);
    164 }
    165 
    166 bool RlzValueStoreRegistry::HasAccess(AccessType type) {
    167   return HasUserKeyAccess(type == kWriteAccess);
    168 }
    169 
    170 bool RlzValueStoreRegistry::WritePingTime(Product product, int64 time) {
    171   base::win::RegKey key;
    172   std::wstring product_name = GetWideProductName(product);
    173   return GetPingTimesRegKey(KEY_WRITE, &key) &&
    174       key.WriteValue(product_name.c_str(), &time, sizeof(time),
    175                      REG_QWORD) == ERROR_SUCCESS;
    176 }
    177 
    178 bool RlzValueStoreRegistry::ReadPingTime(Product product, int64* time) {
    179   base::win::RegKey key;
    180   std::wstring product_name = GetWideProductName(product);
    181   return GetPingTimesRegKey(KEY_READ, &key) &&
    182       key.ReadInt64(product_name.c_str(), time) == ERROR_SUCCESS;
    183 }
    184 
    185 bool RlzValueStoreRegistry::ClearPingTime(Product product) {
    186   base::win::RegKey key;
    187   GetPingTimesRegKey(KEY_WRITE, &key);
    188 
    189   std::wstring product_name = GetWideProductName(product);
    190   key.DeleteValue(product_name.c_str());
    191 
    192   // Verify deletion.
    193   uint64 value;
    194   DWORD size = sizeof(value);
    195   if (key.ReadValue(
    196         product_name.c_str(), &value, &size, NULL) == ERROR_SUCCESS) {
    197     ASSERT_STRING("RlzValueStoreRegistry::ClearPingTime: Failed to delete.");
    198     return false;
    199   }
    200 
    201   return true;
    202 }
    203 
    204 bool RlzValueStoreRegistry::WriteAccessPointRlz(AccessPoint access_point,
    205                                                 const char* new_rlz) {
    206   const char* access_point_name = GetAccessPointName(access_point);
    207   if (!access_point_name)
    208     return false;
    209 
    210   std::wstring access_point_name_wide(ASCIIToWide(access_point_name));
    211   base::win::RegKey key;
    212   GetAccessPointRlzsRegKey(KEY_WRITE, &key);
    213 
    214   if (!RegKeyWriteValue(key, access_point_name_wide.c_str(), new_rlz)) {
    215     ASSERT_STRING("SetAccessPointRlz: Could not write the new RLZ value");
    216     return false;
    217   }
    218   return true;
    219 }
    220 
    221 bool RlzValueStoreRegistry::ReadAccessPointRlz(AccessPoint access_point,
    222                                                char* rlz,
    223                                                size_t rlz_size) {
    224   const char* access_point_name = GetAccessPointName(access_point);
    225   if (!access_point_name)
    226     return false;
    227 
    228   size_t size = rlz_size;
    229   base::win::RegKey key;
    230   GetAccessPointRlzsRegKey(KEY_READ, &key);
    231   if (!RegKeyReadValue(key, ASCIIToWide(access_point_name).c_str(),
    232                        rlz, &size)) {
    233     rlz[0] = 0;
    234     if (size > rlz_size) {
    235       ASSERT_STRING("GetAccessPointRlz: Insufficient buffer size");
    236       return false;
    237     }
    238   }
    239   return true;
    240 }
    241 
    242 bool RlzValueStoreRegistry::ClearAccessPointRlz(AccessPoint access_point) {
    243   const char* access_point_name = GetAccessPointName(access_point);
    244   if (!access_point_name)
    245     return false;
    246 
    247   std::wstring access_point_name_wide(ASCIIToWide(access_point_name));
    248   base::win::RegKey key;
    249   GetAccessPointRlzsRegKey(KEY_WRITE, &key);
    250 
    251   key.DeleteValue(access_point_name_wide.c_str());
    252 
    253   // Verify deletion.
    254   DWORD value;
    255   if (key.ReadValueDW(access_point_name_wide.c_str(), &value) ==
    256       ERROR_SUCCESS) {
    257     ASSERT_STRING("SetAccessPointRlz: Could not clear the RLZ value.");
    258     return false;
    259   }
    260   return true;
    261 }
    262 
    263 bool RlzValueStoreRegistry::AddProductEvent(Product product,
    264                                             const char* event_rlz) {
    265   std::wstring event_rlz_wide(ASCIIToWide(event_rlz));
    266   base::win::RegKey reg_key;
    267   GetEventsRegKey(kEventsSubkeyName, &product, KEY_WRITE, &reg_key);
    268   if (reg_key.WriteValue(event_rlz_wide.c_str(), 1) != ERROR_SUCCESS) {
    269     ASSERT_STRING("AddProductEvent: Could not write the new event value");
    270     return false;
    271   }
    272 
    273   return true;
    274 }
    275 
    276 bool RlzValueStoreRegistry::ReadProductEvents(Product product,
    277                                              std::vector<std::string>* events) {
    278   // Open the events key.
    279   base::win::RegKey events_key;
    280   GetEventsRegKey(kEventsSubkeyName, &product, KEY_READ, &events_key);
    281   if (!events_key.Valid())
    282     return false;
    283 
    284   // Append the events to the buffer.
    285   int num_values = 0;
    286   LONG result = ERROR_SUCCESS;
    287   for (num_values = 0; result == ERROR_SUCCESS; ++num_values) {
    288     // Max 32767 bytes according to MSDN, but we never use that much.
    289     const size_t kMaxValueNameLength = 2048;
    290     char buffer[kMaxValueNameLength];
    291     DWORD size = arraysize(buffer);
    292 
    293     result = RegEnumValueA(events_key.Handle(), num_values, buffer, &size,
    294                            NULL, NULL, NULL, NULL);
    295     if (result == ERROR_SUCCESS)
    296       events->push_back(std::string(buffer));
    297   }
    298 
    299   return result == ERROR_NO_MORE_ITEMS;
    300 }
    301 
    302 bool RlzValueStoreRegistry::ClearProductEvent(Product product,
    303                                               const char* event_rlz) {
    304   std::wstring event_rlz_wide(ASCIIToWide(event_rlz));
    305   base::win::RegKey key;
    306   GetEventsRegKey(kEventsSubkeyName, &product, KEY_WRITE, &key);
    307   key.DeleteValue(event_rlz_wide.c_str());
    308 
    309   // Verify deletion.
    310   DWORD value;
    311   if (key.ReadValueDW(event_rlz_wide.c_str(), &value) == ERROR_SUCCESS) {
    312     ASSERT_STRING("ClearProductEvent: Could not delete the event value.");
    313     return false;
    314   }
    315 
    316   return true;
    317 }
    318 
    319 bool RlzValueStoreRegistry::ClearAllProductEvents(Product product) {
    320   return ClearAllProductEventValues(product, kEventsSubkeyName);
    321 }
    322 
    323 bool RlzValueStoreRegistry::AddStatefulEvent(Product product,
    324                                              const char* event_rlz) {
    325   base::win::RegKey key;
    326   std::wstring event_rlz_wide(ASCIIToWide(event_rlz));
    327   if (!GetEventsRegKey(kStatefulEventsSubkeyName, &product, KEY_WRITE, &key) ||
    328       key.WriteValue(event_rlz_wide.c_str(), 1) != ERROR_SUCCESS) {
    329     ASSERT_STRING(
    330         "AddStatefulEvent: Could not write the new stateful event");
    331     return false;
    332   }
    333 
    334   return true;
    335 }
    336 
    337 bool RlzValueStoreRegistry::IsStatefulEvent(Product product,
    338                                             const char* event_rlz) {
    339   DWORD value;
    340   base::win::RegKey key;
    341   GetEventsRegKey(kStatefulEventsSubkeyName, &product, KEY_READ, &key);
    342   std::wstring event_rlz_wide(ASCIIToWide(event_rlz));
    343   return key.ReadValueDW(event_rlz_wide.c_str(), &value) == ERROR_SUCCESS;
    344 }
    345 
    346 bool RlzValueStoreRegistry::ClearAllStatefulEvents(Product product) {
    347   return ClearAllProductEventValues(product, kStatefulEventsSubkeyName);
    348 }
    349 
    350 void RlzValueStoreRegistry::CollectGarbage() {
    351   // Delete each of the known subkeys if empty.
    352   const char* subkeys[] = {
    353     kRlzsSubkeyName,
    354     kEventsSubkeyName,
    355     kStatefulEventsSubkeyName,
    356     kPingTimesSubkeyName
    357   };
    358 
    359   for (int i = 0; i < arraysize(subkeys); i++) {
    360     std::string subkey_name;
    361     base::StringAppendF(&subkey_name, "%s\\%s", kLibKeyName, subkeys[i]);
    362     AppendBrandToString(&subkey_name);
    363 
    364     VERIFY(DeleteKeyIfEmpty(HKEY_CURRENT_USER,
    365                             ASCIIToWide(subkey_name).c_str()));
    366   }
    367 
    368   // Delete the library key and its parents too now if empty.
    369   VERIFY(DeleteKeyIfEmpty(HKEY_CURRENT_USER, GetWideLibKeyName().c_str()));
    370   VERIFY(DeleteKeyIfEmpty(HKEY_CURRENT_USER, kGoogleCommonKeyName));
    371   VERIFY(DeleteKeyIfEmpty(HKEY_CURRENT_USER, kGoogleKeyName));
    372 }
    373 
    374 ScopedRlzValueStoreLock::ScopedRlzValueStoreLock() {
    375   if (!lock_.failed())
    376     store_.reset(new RlzValueStoreRegistry);
    377 }
    378 
    379 ScopedRlzValueStoreLock::~ScopedRlzValueStoreLock() {
    380 }
    381 
    382 RlzValueStore* ScopedRlzValueStoreLock::GetStore() {
    383   return store_.get();
    384 }
    385 
    386 }  // namespace rlz_lib
    387