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
34namespace chromeos_update_engine {
35
36class 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.
44class 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