1 // 2 // Copyright (C) 2012 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_OMAHA_REQUEST_PARAMS_H_ 18 #define UPDATE_ENGINE_OMAHA_REQUEST_PARAMS_H_ 19 20 #include <stdint.h> 21 22 #include <string> 23 24 #include <base/macros.h> 25 #include <base/time/time.h> 26 #include <gtest/gtest_prod.h> // for FRIEND_TEST 27 28 #include "update_engine/common/platform_constants.h" 29 #include "update_engine/image_properties.h" 30 31 // This gathers local system information and prepares info used by the 32 // Omaha request action. 33 34 namespace chromeos_update_engine { 35 36 class SystemState; 37 38 // This class encapsulates the data Omaha gets for the request, along with 39 // essential state needed for the processing of the request/response. The 40 // strings in this struct should not be XML escaped. 41 // 42 // TODO(jaysri): chromium-os:39752 tracks the need to rename this class to 43 // reflect its lifetime more appropriately. 44 class OmahaRequestParams { 45 public: 46 explicit OmahaRequestParams(SystemState* system_state) 47 : system_state_(system_state), 48 os_platform_(constants::kOmahaPlatformName), 49 os_version_(kOsVersion), 50 delta_okay_(true), 51 interactive_(false), 52 wall_clock_based_wait_enabled_(false), 53 update_check_count_wait_enabled_(false), 54 min_update_checks_needed_(kDefaultMinUpdateChecks), 55 max_update_checks_allowed_(kDefaultMaxUpdateChecks) {} 56 57 OmahaRequestParams(SystemState* system_state, 58 const std::string& in_os_platform, 59 const std::string& in_os_version, 60 const std::string& in_os_sp, 61 const std::string& in_os_board, 62 const std::string& in_app_id, 63 const std::string& in_app_version, 64 const std::string& in_app_lang, 65 const std::string& in_target_channel, 66 const std::string& in_hwid, 67 const std::string& in_fw_version, 68 const std::string& in_ec_version, 69 bool in_delta_okay, 70 bool in_interactive, 71 const std::string& in_update_url, 72 const std::string& in_target_version_prefix) 73 : system_state_(system_state), 74 os_platform_(in_os_platform), 75 os_version_(in_os_version), 76 os_sp_(in_os_sp), 77 app_lang_(in_app_lang), 78 hwid_(in_hwid), 79 fw_version_(in_fw_version), 80 ec_version_(in_ec_version), 81 delta_okay_(in_delta_okay), 82 interactive_(in_interactive), 83 update_url_(in_update_url), 84 target_version_prefix_(in_target_version_prefix), 85 wall_clock_based_wait_enabled_(false), 86 update_check_count_wait_enabled_(false), 87 min_update_checks_needed_(kDefaultMinUpdateChecks), 88 max_update_checks_allowed_(kDefaultMaxUpdateChecks) { 89 image_props_.board = in_os_board; 90 image_props_.product_id = in_app_id; 91 image_props_.canary_product_id = in_app_id; 92 image_props_.version = in_app_version; 93 image_props_.current_channel = in_target_channel; 94 mutable_image_props_.target_channel = in_target_channel; 95 mutable_image_props_.is_powerwash_allowed = false; 96 } 97 98 virtual ~OmahaRequestParams(); 99 100 // Setters and getters for the various properties. 101 inline std::string os_platform() const { return os_platform_; } 102 inline std::string os_version() const { return os_version_; } 103 inline std::string os_sp() const { return os_sp_; } 104 inline std::string os_board() const { return image_props_.board; } 105 inline std::string board_app_id() const { return image_props_.product_id; } 106 inline std::string canary_app_id() const { 107 return image_props_.canary_product_id; 108 } 109 inline std::string app_lang() const { return app_lang_; } 110 inline std::string hwid() const { return hwid_; } 111 inline std::string fw_version() const { return fw_version_; } 112 inline std::string ec_version() const { return ec_version_; } 113 114 inline void set_app_version(const std::string& version) { 115 image_props_.version = version; 116 } 117 inline std::string app_version() const { return image_props_.version; } 118 119 inline std::string current_channel() const { 120 return image_props_.current_channel; 121 } 122 inline std::string target_channel() const { 123 return mutable_image_props_.target_channel; 124 } 125 inline std::string download_channel() const { return download_channel_; } 126 127 // Can client accept a delta ? 128 inline void set_delta_okay(bool ok) { delta_okay_ = ok; } 129 inline bool delta_okay() const { return delta_okay_; } 130 131 // True if this is a user-initiated update check. 132 inline void set_interactive(bool interactive) { interactive_ = interactive; } 133 inline bool interactive() const { return interactive_; } 134 135 inline void set_update_url(const std::string& url) { update_url_ = url; } 136 inline std::string update_url() const { return update_url_; } 137 138 inline void set_target_version_prefix(const std::string& prefix) { 139 target_version_prefix_ = prefix; 140 } 141 142 inline std::string target_version_prefix() const { 143 return target_version_prefix_; 144 } 145 146 inline void set_wall_clock_based_wait_enabled(bool enabled) { 147 wall_clock_based_wait_enabled_ = enabled; 148 } 149 inline bool wall_clock_based_wait_enabled() const { 150 return wall_clock_based_wait_enabled_; 151 } 152 153 inline void set_waiting_period(base::TimeDelta period) { 154 waiting_period_ = period; 155 } 156 base::TimeDelta waiting_period() const { return waiting_period_; } 157 158 inline void set_update_check_count_wait_enabled(bool enabled) { 159 update_check_count_wait_enabled_ = enabled; 160 } 161 162 inline bool update_check_count_wait_enabled() const { 163 return update_check_count_wait_enabled_; 164 } 165 166 inline void set_min_update_checks_needed(int64_t min) { 167 min_update_checks_needed_ = min; 168 } 169 inline int64_t min_update_checks_needed() const { 170 return min_update_checks_needed_; 171 } 172 173 inline void set_max_update_checks_allowed(int64_t max) { 174 max_update_checks_allowed_ = max; 175 } 176 inline int64_t max_update_checks_allowed() const { 177 return max_update_checks_allowed_; 178 } 179 180 // True if we're trying to update to a more stable channel. 181 // i.e. index(target_channel) > index(current_channel). 182 virtual bool to_more_stable_channel() const; 183 184 // Returns the app id corresponding to the current value of the 185 // download channel. 186 virtual std::string GetAppId() const; 187 188 // Suggested defaults 189 static const char kOsVersion[]; 190 static const char kIsPowerwashAllowedKey[]; 191 static const int64_t kDefaultMinUpdateChecks = 0; 192 static const int64_t kDefaultMaxUpdateChecks = 8; 193 194 // Initializes all the data in the object. Non-empty 195 // |in_app_version| or |in_update_url| prevents automatic detection 196 // of the parameter. Returns true on success, false otherwise. 197 bool Init(const std::string& in_app_version, 198 const std::string& in_update_url, 199 bool in_interactive); 200 201 // Permanently changes the release channel to |channel|. Performs a 202 // powerwash, if required and allowed. 203 // Returns true on success, false otherwise. Note: This call will fail if 204 // there's a channel change pending already. This is to serialize all the 205 // channel changes done by the user in order to avoid having to solve 206 // numerous edge cases around ensuring the powerwash happens as intended in 207 // all such cases. 208 virtual bool SetTargetChannel(const std::string& channel, 209 bool is_powerwash_allowed, 210 std::string* error_message); 211 212 // Updates the download channel for this particular attempt from the current 213 // value of target channel. This method takes a "snapshot" of the current 214 // value of target channel and uses it for all subsequent Omaha requests for 215 // this attempt (i.e. initial request as well as download progress/error 216 // event requests). The snapshot will be updated only when either this method 217 // or Init is called again. 218 virtual void UpdateDownloadChannel(); 219 220 virtual bool is_powerwash_allowed() const { 221 return mutable_image_props_.is_powerwash_allowed; 222 } 223 224 // Check if the provided update URL is official, meaning either the default 225 // autoupdate server or the autoupdate autotest server. 226 virtual bool IsUpdateUrlOfficial() const; 227 228 // For unit-tests. 229 void set_root(const std::string& root); 230 void set_current_channel(const std::string& channel) { 231 image_props_.current_channel = channel; 232 } 233 void set_target_channel(const std::string& channel) { 234 mutable_image_props_.target_channel = channel; 235 } 236 237 private: 238 FRIEND_TEST(OmahaRequestParamsTest, IsValidChannelTest); 239 FRIEND_TEST(OmahaRequestParamsTest, ShouldLockDownTest); 240 FRIEND_TEST(OmahaRequestParamsTest, ChannelIndexTest); 241 FRIEND_TEST(OmahaRequestParamsTest, LsbPreserveTest); 242 FRIEND_TEST(OmahaRequestParamsTest, CollectECFWVersionsTest); 243 244 // Returns true if |channel| is a valid channel, false otherwise. 245 bool IsValidChannel(const std::string& channel) const; 246 247 // Returns the index of the given channel. 248 int GetChannelIndex(const std::string& channel) const; 249 250 // Returns True if we should store the fw/ec versions based on our hwid_. 251 // Compares hwid to a set of whitelisted prefixes. 252 bool CollectECFWVersions() const; 253 254 // These are individual helper methods to initialize the said properties from 255 // the LSB value. 256 void SetTargetChannelFromLsbValue(); 257 void SetCurrentChannelFromLsbValue(); 258 void SetIsPowerwashAllowedFromLsbValue(); 259 260 // Initializes the required properties from the LSB value. 261 void InitFromLsbValue(); 262 263 // Gets the machine type (e.g. "i686"). 264 std::string GetMachineType() const; 265 266 // Global system context. 267 SystemState* system_state_; 268 269 // The system image properties. 270 ImageProperties image_props_; 271 MutableImageProperties mutable_image_props_; 272 273 // Basic properties of the OS and Application that go into the Omaha request. 274 std::string os_platform_; 275 std::string os_version_; 276 std::string os_sp_; 277 std::string app_lang_; 278 279 // There are three channel values we deal with: 280 // * The channel we got the image we are running from or "current channel" 281 // stored in |image_props_.current_channel|. 282 // 283 // * The release channel we are tracking, where we should get updates from, 284 // stored in |mutable_image_props_.target_channel|. This channel is 285 // normally the same as the current_channel, except when the user changes 286 // the channel. In that case it'll have the release channel the user 287 // switched to, regardless of whether we downloaded an update from that 288 // channel or not, or if we are in the middle of a download from a 289 // previously selected channel (as opposed to download channel 290 // which gets updated only at the start of next download). 291 // 292 // * The channel from which we're downloading the payload. This should 293 // normally be the same as target channel. But if the user made another 294 // channel change after we started the download, then they'd be different, 295 // in which case, we'd detect elsewhere that the target channel has been 296 // changed and cancel the current download attempt. 297 std::string download_channel_; 298 299 std::string hwid_; // Hardware Qualification ID of the client 300 std::string fw_version_; // Chrome OS Firmware Version. 301 std::string ec_version_; // Chrome OS EC Version. 302 bool delta_okay_; // If this client can accept a delta 303 bool interactive_; // Whether this is a user-initiated update check 304 305 // The URL to send the Omaha request to. 306 std::string update_url_; 307 308 // Prefix of the target OS version that the enterprise wants this device 309 // to be pinned to. It's empty otherwise. 310 std::string target_version_prefix_; 311 312 // True if scattering is enabled, in which case waiting_period_ specifies the 313 // amount of absolute time that we've to wait for before sending a request to 314 // Omaha. 315 bool wall_clock_based_wait_enabled_; 316 base::TimeDelta waiting_period_; 317 318 // True if scattering is enabled to denote the number of update checks 319 // we've to skip before we can send a request to Omaha. The min and max 320 // values establish the bounds for a random number to be chosen within that 321 // range to enable such a wait. 322 bool update_check_count_wait_enabled_; 323 int64_t min_update_checks_needed_; 324 int64_t max_update_checks_allowed_; 325 326 // When reading files, prepend root_ to the paths. Useful for testing. 327 std::string root_; 328 329 // TODO(jaysri): Uncomment this after fixing unit tests, as part of 330 // chromium-os:39752 331 // DISALLOW_COPY_AND_ASSIGN(OmahaRequestParams); 332 }; 333 334 } // namespace chromeos_update_engine 335 336 #endif // UPDATE_ENGINE_OMAHA_REQUEST_PARAMS_H_ 337
