1 // 2 // Copyright (C) 2013 The Android Open Source Project 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #ifndef UPDATE_ENGINE_COMMON_FAKE_HARDWARE_H_ 18 #define UPDATE_ENGINE_COMMON_FAKE_HARDWARE_H_ 19 20 #include <map> 21 #include <string> 22 23 #include <base/time/time.h> 24 25 #include "update_engine/common/hardware_interface.h" 26 27 namespace chromeos_update_engine { 28 29 // Implements a fake hardware interface used for testing. 30 class FakeHardware : public HardwareInterface { 31 public: 32 // Value used to signal that the powerwash_count file is not present. When 33 // this value is used in SetPowerwashCount(), GetPowerwashCount() will return 34 // false. 35 static const int kPowerwashCountNotSet = -1; 36 37 // Default value for crossystem tpm_kernver. 38 static const int kMinKernelKeyVersion = 3; 39 40 // Default value for crossystem tpm_fwver. 41 static const int kMinFirmwareKeyVersion = 13; 42 43 // Default value for crossystem kernel_max_rollforward. This value is the 44 // default for consumer devices and effectively means "unlimited rollforward 45 // is allowed", which is the same as the behavior prior to implementing 46 // roll forward prevention. 47 static const int kKernelMaxRollforward = 0xfffffffe; 48 49 // Default value for crossystem firmware_max_rollforward. This value is the 50 // default for consumer devices and effectively means "unlimited rollforward 51 // is allowed", which is the same as the behavior prior to implementing 52 // roll forward prevention. 53 static const int kFirmwareMaxRollforward = 0xfffffffe; 54 55 FakeHardware() = default; 56 57 // HardwareInterface methods. IsOfficialBuild()58 bool IsOfficialBuild() const override { return is_official_build_; } 59 IsNormalBootMode()60 bool IsNormalBootMode() const override { return is_normal_boot_mode_; } 61 AreDevFeaturesEnabled()62 bool AreDevFeaturesEnabled() const override { 63 return are_dev_features_enabled_; 64 } 65 IsOOBEEnabled()66 bool IsOOBEEnabled() const override { return is_oobe_enabled_; } 67 IsOOBEComplete(base::Time * out_time_of_oobe)68 bool IsOOBEComplete(base::Time* out_time_of_oobe) const override { 69 if (out_time_of_oobe != nullptr) 70 *out_time_of_oobe = oobe_timestamp_; 71 return is_oobe_complete_; 72 } 73 GetHardwareClass()74 std::string GetHardwareClass() const override { return hardware_class_; } 75 GetFirmwareVersion()76 std::string GetFirmwareVersion() const override { return firmware_version_; } 77 GetECVersion()78 std::string GetECVersion() const override { return ec_version_; } 79 GetMinKernelKeyVersion()80 int GetMinKernelKeyVersion() const override { 81 return min_kernel_key_version_; 82 } 83 GetMinFirmwareKeyVersion()84 int GetMinFirmwareKeyVersion() const override { 85 return min_firmware_key_version_; 86 } 87 GetMaxFirmwareKeyRollforward()88 int GetMaxFirmwareKeyRollforward() const override { 89 return firmware_max_rollforward_; 90 } 91 SetMaxFirmwareKeyRollforward(int firmware_max_rollforward)92 bool SetMaxFirmwareKeyRollforward(int firmware_max_rollforward) override { 93 if (GetMaxFirmwareKeyRollforward() == -1) 94 return false; 95 96 firmware_max_rollforward_ = firmware_max_rollforward; 97 return true; 98 } 99 SetMaxKernelKeyRollforward(int kernel_max_rollforward)100 bool SetMaxKernelKeyRollforward(int kernel_max_rollforward) override { 101 kernel_max_rollforward_ = kernel_max_rollforward; 102 return true; 103 } 104 GetPowerwashCount()105 int GetPowerwashCount() const override { return powerwash_count_; } 106 SchedulePowerwash(bool is_rollback)107 bool SchedulePowerwash(bool is_rollback) override { 108 powerwash_scheduled_ = true; 109 is_rollback_powerwash_ = is_rollback; 110 return true; 111 } 112 CancelPowerwash()113 bool CancelPowerwash() override { 114 powerwash_scheduled_ = false; 115 is_rollback_powerwash_ = false; 116 return true; 117 } 118 IsPowerwashScheduled()119 bool IsPowerwashScheduled() { return powerwash_scheduled_; } 120 GetNonVolatileDirectory(base::FilePath * path)121 bool GetNonVolatileDirectory(base::FilePath* path) const override { 122 return false; 123 } 124 GetPowerwashSafeDirectory(base::FilePath * path)125 bool GetPowerwashSafeDirectory(base::FilePath* path) const override { 126 return false; 127 } 128 GetBuildTimestamp()129 int64_t GetBuildTimestamp() const override { return build_timestamp_; } 130 GetFirstActiveOmahaPingSent()131 bool GetFirstActiveOmahaPingSent() const override { 132 return first_active_omaha_ping_sent_; 133 } 134 SetFirstActiveOmahaPingSent()135 bool SetFirstActiveOmahaPingSent() override { 136 first_active_omaha_ping_sent_ = true; 137 return true; 138 } 139 140 // Setters SetIsOfficialBuild(bool is_official_build)141 void SetIsOfficialBuild(bool is_official_build) { 142 is_official_build_ = is_official_build; 143 } 144 SetIsNormalBootMode(bool is_normal_boot_mode)145 void SetIsNormalBootMode(bool is_normal_boot_mode) { 146 is_normal_boot_mode_ = is_normal_boot_mode; 147 } 148 SetAreDevFeaturesEnabled(bool are_dev_features_enabled)149 void SetAreDevFeaturesEnabled(bool are_dev_features_enabled) { 150 are_dev_features_enabled_ = are_dev_features_enabled; 151 } 152 153 // Sets the SetIsOOBEEnabled to |is_oobe_enabled|. SetIsOOBEEnabled(bool is_oobe_enabled)154 void SetIsOOBEEnabled(bool is_oobe_enabled) { 155 is_oobe_enabled_ = is_oobe_enabled; 156 } 157 158 // Sets the IsOOBEComplete to True with the given timestamp. SetIsOOBEComplete(base::Time oobe_timestamp)159 void SetIsOOBEComplete(base::Time oobe_timestamp) { 160 is_oobe_complete_ = true; 161 oobe_timestamp_ = oobe_timestamp; 162 } 163 UnsetIsOOBEComplete()164 void UnsetIsOOBEComplete() { is_oobe_complete_ = false; } 165 SetHardwareClass(const std::string & hardware_class)166 void SetHardwareClass(const std::string& hardware_class) { 167 hardware_class_ = hardware_class; 168 } 169 SetFirmwareVersion(const std::string & firmware_version)170 void SetFirmwareVersion(const std::string& firmware_version) { 171 firmware_version_ = firmware_version; 172 } 173 SetECVersion(const std::string & ec_version)174 void SetECVersion(const std::string& ec_version) { ec_version_ = ec_version; } 175 SetMinKernelKeyVersion(int min_kernel_key_version)176 void SetMinKernelKeyVersion(int min_kernel_key_version) { 177 min_kernel_key_version_ = min_kernel_key_version; 178 } 179 SetMinFirmwareKeyVersion(int min_firmware_key_version)180 void SetMinFirmwareKeyVersion(int min_firmware_key_version) { 181 min_firmware_key_version_ = min_firmware_key_version; 182 } 183 SetPowerwashCount(int powerwash_count)184 void SetPowerwashCount(int powerwash_count) { 185 powerwash_count_ = powerwash_count; 186 } 187 SetBuildTimestamp(int64_t build_timestamp)188 void SetBuildTimestamp(int64_t build_timestamp) { 189 build_timestamp_ = build_timestamp; 190 } 191 192 // Getters to verify state. GetMaxKernelKeyRollforward()193 int GetMaxKernelKeyRollforward() const { return kernel_max_rollforward_; } 194 GetIsRollbackPowerwashScheduled()195 bool GetIsRollbackPowerwashScheduled() const { 196 return powerwash_scheduled_ && is_rollback_powerwash_; 197 } 198 199 private: 200 bool is_official_build_{true}; 201 bool is_normal_boot_mode_{true}; 202 bool are_dev_features_enabled_{false}; 203 bool is_oobe_enabled_{true}; 204 bool is_oobe_complete_{true}; 205 // Jan 20, 2007 206 base::Time oobe_timestamp_{base::Time::FromTimeT(1169280000)}; 207 std::string hardware_class_{"Fake HWID BLAH-1234"}; 208 std::string firmware_version_{"Fake Firmware v1.0.1"}; 209 std::string ec_version_{"Fake EC v1.0a"}; 210 int min_kernel_key_version_{kMinKernelKeyVersion}; 211 int min_firmware_key_version_{kMinFirmwareKeyVersion}; 212 int kernel_max_rollforward_{kKernelMaxRollforward}; 213 int firmware_max_rollforward_{kFirmwareMaxRollforward}; 214 int powerwash_count_{kPowerwashCountNotSet}; 215 bool powerwash_scheduled_{false}; 216 bool is_rollback_powerwash_{false}; 217 int64_t build_timestamp_{0}; 218 bool first_active_omaha_ping_sent_{false}; 219 220 DISALLOW_COPY_AND_ASSIGN(FakeHardware); 221 }; 222 223 } // namespace chromeos_update_engine 224 225 #endif // UPDATE_ENGINE_COMMON_FAKE_HARDWARE_H_ 226