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 os_build_fingerprint() const { 106 return image_props_.build_fingerprint; 107 } 108 inline std::string os_build_type() const { return image_props_.build_type; } 109 inline std::string board_app_id() const { return image_props_.product_id; } 110 inline std::string canary_app_id() const { 111 return image_props_.canary_product_id; 112 } 113 inline std::string system_app_id() const { return image_props_.system_id; } 114 inline void set_app_id(const std::string& app_id) { 115 image_props_.product_id = app_id; 116 image_props_.canary_product_id = app_id; 117 } 118 inline std::string app_lang() const { return app_lang_; } 119 inline std::string hwid() const { return hwid_; } 120 inline std::string fw_version() const { return fw_version_; } 121 inline std::string ec_version() const { return ec_version_; } 122 123 inline void set_app_version(const std::string& version) { 124 image_props_.version = version; 125 } 126 inline std::string app_version() const { return image_props_.version; } 127 inline std::string system_version() const { 128 return image_props_.system_version; 129 } 130 131 inline std::string current_channel() const { 132 return image_props_.current_channel; 133 } 134 inline std::string target_channel() const { 135 return mutable_image_props_.target_channel; 136 } 137 inline std::string download_channel() const { return download_channel_; } 138 139 // Can client accept a delta ? 140 inline void set_delta_okay(bool ok) { delta_okay_ = ok; } 141 inline bool delta_okay() const { return delta_okay_; } 142 143 // True if this is a user-initiated update check. 144 inline void set_interactive(bool interactive) { interactive_ = interactive; } 145 inline bool interactive() const { return interactive_; } 146 147 inline void set_update_url(const std::string& url) { update_url_ = url; } 148 inline std::string update_url() const { return update_url_; } 149 150 inline void set_target_version_prefix(const std::string& prefix) { 151 target_version_prefix_ = prefix; 152 } 153 154 inline std::string target_version_prefix() const { 155 return target_version_prefix_; 156 } 157 158 inline void set_wall_clock_based_wait_enabled(bool enabled) { 159 wall_clock_based_wait_enabled_ = enabled; 160 } 161 inline bool wall_clock_based_wait_enabled() const { 162 return wall_clock_based_wait_enabled_; 163 } 164 165 inline void set_waiting_period(base::TimeDelta period) { 166 waiting_period_ = period; 167 } 168 base::TimeDelta waiting_period() const { return waiting_period_; } 169 170 inline void set_update_check_count_wait_enabled(bool enabled) { 171 update_check_count_wait_enabled_ = enabled; 172 } 173 174 inline bool update_check_count_wait_enabled() const { 175 return update_check_count_wait_enabled_; 176 } 177 178 inline void set_min_update_checks_needed(int64_t min) { 179 min_update_checks_needed_ = min; 180 } 181 inline int64_t min_update_checks_needed() const { 182 return min_update_checks_needed_; 183 } 184 185 inline void set_max_update_checks_allowed(int64_t max) { 186 max_update_checks_allowed_ = max; 187 } 188 inline int64_t max_update_checks_allowed() const { 189 return max_update_checks_allowed_; 190 } 191 192 // True if we're trying to update to a more stable channel. 193 // i.e. index(target_channel) > index(current_channel). 194 virtual bool to_more_stable_channel() const; 195 196 // Returns the app id corresponding to the current value of the 197 // download channel. 198 virtual std::string GetAppId() const; 199 200 // Suggested defaults 201 static const char kOsVersion[]; 202 static const char kIsPowerwashAllowedKey[]; 203 static const int64_t kDefaultMinUpdateChecks = 0; 204 static const int64_t kDefaultMaxUpdateChecks = 8; 205 206 // Initializes all the data in the object. Non-empty 207 // |in_app_version| or |in_update_url| prevents automatic detection 208 // of the parameter. Returns true on success, false otherwise. 209 bool Init(const std::string& in_app_version, 210 const std::string& in_update_url, 211 bool in_interactive); 212 213 // Permanently changes the release channel to |channel|. Performs a 214 // powerwash, if required and allowed. 215 // Returns true on success, false otherwise. Note: This call will fail if 216 // there's a channel change pending already. This is to serialize all the 217 // channel changes done by the user in order to avoid having to solve 218 // numerous edge cases around ensuring the powerwash happens as intended in 219 // all such cases. 220 virtual bool SetTargetChannel(const std::string& channel, 221 bool is_powerwash_allowed, 222 std::string* error_message); 223 224 // Updates the download channel for this particular attempt from the current 225 // value of target channel. This method takes a "snapshot" of the current 226 // value of target channel and uses it for all subsequent Omaha requests for 227 // this attempt (i.e. initial request as well as download progress/error 228 // event requests). The snapshot will be updated only when either this method 229 // or Init is called again. 230 virtual void UpdateDownloadChannel(); 231 232 virtual bool is_powerwash_allowed() const { 233 return mutable_image_props_.is_powerwash_allowed; 234 } 235 236 // Check if the provided update URL is official, meaning either the default 237 // autoupdate server or the autoupdate autotest server. 238 virtual bool IsUpdateUrlOfficial() const; 239 240 // For unit-tests. 241 void set_root(const std::string& root); 242 void set_current_channel(const std::string& channel) { 243 image_props_.current_channel = channel; 244 } 245 void set_target_channel(const std::string& channel) { 246 mutable_image_props_.target_channel = channel; 247 } 248 249 private: 250 FRIEND_TEST(OmahaRequestParamsTest, IsValidChannelTest); 251 FRIEND_TEST(OmahaRequestParamsTest, ChannelIndexTest); 252 FRIEND_TEST(OmahaRequestParamsTest, ToMoreStableChannelFlagTest); 253 FRIEND_TEST(OmahaRequestParamsTest, CollectECFWVersionsTest); 254 255 // Returns true if |channel| is a valid channel, false otherwise. 256 bool IsValidChannel(const std::string& channel) const; 257 258 // Returns the index of the given channel. 259 int GetChannelIndex(const std::string& channel) const; 260 261 // Returns True if we should store the fw/ec versions based on our hwid_. 262 // Compares hwid to a set of whitelisted prefixes. 263 bool CollectECFWVersions() const; 264 265 // These are individual helper methods to initialize the said properties from 266 // the LSB value. 267 void SetTargetChannelFromLsbValue(); 268 void SetCurrentChannelFromLsbValue(); 269 void SetIsPowerwashAllowedFromLsbValue(); 270 271 // Initializes the required properties from the LSB value. 272 void InitFromLsbValue(); 273 274 // Gets the machine type (e.g. "i686"). 275 std::string GetMachineType() const; 276 277 // Global system context. 278 SystemState* system_state_; 279 280 // The system image properties. 281 ImageProperties image_props_; 282 MutableImageProperties mutable_image_props_; 283 284 // Basic properties of the OS and Application that go into the Omaha request. 285 std::string os_platform_; 286 std::string os_version_; 287 std::string os_sp_; 288 std::string app_lang_; 289 290 // There are three channel values we deal with: 291 // * The channel we got the image we are running from or "current channel" 292 // stored in |image_props_.current_channel|. 293 // 294 // * The release channel we are tracking, where we should get updates from, 295 // stored in |mutable_image_props_.target_channel|. This channel is 296 // normally the same as the current_channel, except when the user changes 297 // the channel. In that case it'll have the release channel the user 298 // switched to, regardless of whether we downloaded an update from that 299 // channel or not, or if we are in the middle of a download from a 300 // previously selected channel (as opposed to download channel 301 // which gets updated only at the start of next download). 302 // 303 // * The channel from which we're downloading the payload. This should 304 // normally be the same as target channel. But if the user made another 305 // channel change after we started the download, then they'd be different, 306 // in which case, we'd detect elsewhere that the target channel has been 307 // changed and cancel the current download attempt. 308 std::string download_channel_; 309 310 std::string hwid_; // Hardware Qualification ID of the client 311 std::string fw_version_; // Chrome OS Firmware Version. 312 std::string ec_version_; // Chrome OS EC Version. 313 bool delta_okay_; // If this client can accept a delta 314 bool interactive_; // Whether this is a user-initiated update check 315 316 // The URL to send the Omaha request to. 317 std::string update_url_; 318 319 // Prefix of the target OS version that the enterprise wants this device 320 // to be pinned to. It's empty otherwise. 321 std::string target_version_prefix_; 322 323 // True if scattering is enabled, in which case waiting_period_ specifies the 324 // amount of absolute time that we've to wait for before sending a request to 325 // Omaha. 326 bool wall_clock_based_wait_enabled_; 327 base::TimeDelta waiting_period_; 328 329 // True if scattering is enabled to denote the number of update checks 330 // we've to skip before we can send a request to Omaha. The min and max 331 // values establish the bounds for a random number to be chosen within that 332 // range to enable such a wait. 333 bool update_check_count_wait_enabled_; 334 int64_t min_update_checks_needed_; 335 int64_t max_update_checks_allowed_; 336 337 // When reading files, prepend root_ to the paths. Useful for testing. 338 std::string root_; 339 340 // TODO(jaysri): Uncomment this after fixing unit tests, as part of 341 // chromium-os:39752 342 // DISALLOW_COPY_AND_ASSIGN(OmahaRequestParams); 343 }; 344 345 } // namespace chromeos_update_engine 346 347 #endif // UPDATE_ENGINE_OMAHA_REQUEST_PARAMS_H_ 348
