1 //
2 // Copyright (C) 2011 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 #include "update_engine/cros/omaha_request_params.h"
18
19 #include <errno.h>
20 #include <fcntl.h>
21 #include <sys/utsname.h>
22
23 #include <map>
24 #include <string>
25 #include <vector>
26
27 #include <base/files/file_util.h>
28 #include <base/stl_util.h>
29 #include <base/strings/string_util.h>
30 #include <base/strings/stringprintf.h>
31 #include <brillo/key_value_store.h>
32 #include <brillo/strings/string_utils.h>
33 #include <policy/device_policy.h>
34
35 #include "update_engine/common/constants.h"
36 #include "update_engine/common/hardware_interface.h"
37 #include "update_engine/common/platform_constants.h"
38 #include "update_engine/common/system_state.h"
39 #include "update_engine/common/utils.h"
40 #include "update_engine/update_manager/policy.h"
41
42 #define CALL_MEMBER_FN(object, member) ((object).*(member))
43
44 using chromeos_update_manager::UpdateCheckParams;
45 using std::string;
46
47 namespace chromeos_update_engine {
48
49 const char OmahaRequestParams::kOsVersion[] = "Indy";
50
51 const char* kChannelsByStability[] = {
52 // This list has to be sorted from least stable to most stable channel.
53 "canary-channel",
54 "dev-channel",
55 "beta-channel",
56 "stable-channel",
57 };
58
~OmahaRequestParams()59 OmahaRequestParams::~OmahaRequestParams() {
60 if (!root_.empty())
61 test::SetImagePropertiesRootPrefix(nullptr);
62 }
63
Init(const string & app_version,const string & update_url,const UpdateCheckParams & params)64 bool OmahaRequestParams::Init(const string& app_version,
65 const string& update_url,
66 const UpdateCheckParams& params) {
67 LOG(INFO) << "Initializing parameters for this update attempt";
68 image_props_ = LoadImageProperties();
69 mutable_image_props_ = LoadMutableImageProperties();
70
71 // Validation check the channel names.
72 if (!IsValidChannel(image_props_.current_channel))
73 image_props_.current_channel = "stable-channel";
74 if (!IsValidChannel(mutable_image_props_.target_channel))
75 mutable_image_props_.target_channel = image_props_.current_channel;
76 UpdateDownloadChannel();
77
78 LOG(INFO) << "Running from channel " << image_props_.current_channel;
79
80 os_platform_ = constants::kOmahaPlatformName;
81 os_version_ = OmahaRequestParams::kOsVersion;
82 if (!app_version.empty())
83 image_props_.version = app_version;
84
85 os_sp_ = image_props_.version + "_" + GetMachineType();
86 app_lang_ = "en-US";
87 hwid_ = SystemState::Get()->hardware()->GetHardwareClass();
88 device_requisition_ = SystemState::Get()->hardware()->GetDeviceRequisition();
89
90 if (image_props_.current_channel == mutable_image_props_.target_channel) {
91 // deltas are only okay if the /.nodelta file does not exist. if we don't
92 // know (i.e. stat() returns some unexpected error), then err on the side of
93 // caution and say deltas are not okay.
94 struct stat stbuf;
95 delta_okay_ =
96 (stat((root_ + "/.nodelta").c_str(), &stbuf) < 0) && (errno == ENOENT);
97 } else {
98 LOG(INFO) << "Disabling deltas as a channel change to "
99 << mutable_image_props_.target_channel
100 << " is pending, with is_powerwash_allowed="
101 << utils::ToString(mutable_image_props_.is_powerwash_allowed);
102 // For now, disable delta updates if the current channel is different from
103 // the channel that we're sending to the update server because such updates
104 // are destined to fail -- the current rootfs hash will be different than
105 // the expected hash due to the different channel in /etc/lsb-release.
106 delta_okay_ = false;
107 }
108
109 if (update_url.empty())
110 update_url_ = image_props_.omaha_url;
111 else
112 update_url_ = update_url;
113
114 // Set the interactive flag accordingly.
115 interactive_ = params.interactive;
116
117 dlc_apps_params_.clear();
118 // Set false so it will do update by default.
119 is_install_ = false;
120
121 target_version_prefix_ = params.target_version_prefix;
122
123 lts_tag_ = params.lts_tag;
124
125 autoupdate_token_ = params.quick_fix_build_token;
126
127 rollback_allowed_ = params.rollback_allowed;
128
129 // Set whether saving data over rollback is requested.
130 rollback_data_save_requested_ = params.rollback_data_save_requested;
131
132 // Set how many milestones of rollback are allowed.
133 rollback_allowed_milestones_ = params.rollback_allowed_milestones;
134
135 // Set the target channel, if one was provided.
136 if (params.target_channel.empty()) {
137 LOG(INFO) << "No target channel mandated by policy.";
138 } else {
139 LOG(INFO) << "Setting target channel as mandated: "
140 << params.target_channel;
141 string error_message;
142 if (!SetTargetChannel(params.target_channel,
143 params.rollback_on_channel_downgrade,
144 &error_message)) {
145 LOG(ERROR) << "Setting the channel failed: " << error_message;
146 }
147
148 // Since this is the beginning of a new attempt, update the download
149 // channel. The download channel won't be updated until the next attempt,
150 // even if target channel changes meanwhile, so that how we'll know if we
151 // should cancel the current download attempt if there's such a change in
152 // target channel.
153 UpdateDownloadChannel();
154 }
155
156 return true;
157 }
158
IsUpdateUrlOfficial() const159 bool OmahaRequestParams::IsUpdateUrlOfficial() const {
160 return (update_url_ == constants::kOmahaDefaultAUTestURL ||
161 update_url_ == image_props_.omaha_url);
162 }
163
SetTargetChannel(const string & new_target_channel,bool is_powerwash_allowed,string * error_message)164 bool OmahaRequestParams::SetTargetChannel(const string& new_target_channel,
165 bool is_powerwash_allowed,
166 string* error_message) {
167 LOG(INFO) << "SetTargetChannel called with " << new_target_channel
168 << ", Is Powerwash Allowed = "
169 << utils::ToString(is_powerwash_allowed)
170 << ". Current channel = " << image_props_.current_channel
171 << ", existing target channel = "
172 << mutable_image_props_.target_channel
173 << ", download channel = " << download_channel_;
174 if (!IsValidChannel(new_target_channel, error_message)) {
175 return false;
176 }
177
178 MutableImageProperties new_props;
179 new_props.target_channel = new_target_channel;
180 new_props.is_powerwash_allowed = is_powerwash_allowed;
181
182 if (!StoreMutableImageProperties(new_props)) {
183 if (error_message)
184 *error_message = "Error storing the new channel value.";
185 return false;
186 }
187 mutable_image_props_ = new_props;
188 return true;
189 }
190
UpdateDownloadChannel()191 void OmahaRequestParams::UpdateDownloadChannel() {
192 if (download_channel_ != mutable_image_props_.target_channel) {
193 download_channel_ = mutable_image_props_.target_channel;
194 LOG(INFO) << "Download channel for this attempt = " << download_channel_;
195 }
196 }
197
GetMachineType() const198 string OmahaRequestParams::GetMachineType() const {
199 struct utsname buf;
200 string ret;
201 if (uname(&buf) == 0)
202 ret = buf.machine;
203 return ret;
204 }
205
IsValidChannel(const string & channel,string * error_message) const206 bool OmahaRequestParams::IsValidChannel(const string& channel,
207 string* error_message) const {
208 if (image_props_.allow_arbitrary_channels) {
209 if (!base::EndsWith(channel, "-channel", base::CompareCase::SENSITIVE)) {
210 if (error_message) {
211 *error_message = base::StringPrintf(
212 "Invalid channel name \"%s\", must ends with -channel.",
213 channel.c_str());
214 }
215 return false;
216 }
217 return true;
218 }
219 if (GetChannelIndex(channel) < 0) {
220 string valid_channels = brillo::string_utils::JoinRange(
221 ", ", std::begin(kChannelsByStability), std::end(kChannelsByStability));
222 if (error_message) {
223 *error_message =
224 base::StringPrintf("Invalid channel name \"%s\", valid names are: %s",
225 channel.c_str(),
226 valid_channels.c_str());
227 }
228 return false;
229 }
230 return true;
231 }
232
set_root(const string & root)233 void OmahaRequestParams::set_root(const string& root) {
234 root_ = root;
235 test::SetImagePropertiesRootPrefix(root_.c_str());
236 }
237
GetChannelIndex(const string & channel) const238 int OmahaRequestParams::GetChannelIndex(const string& channel) const {
239 for (size_t t = 0; t < base::size(kChannelsByStability); ++t)
240 if (channel == kChannelsByStability[t])
241 return t;
242
243 return -1;
244 }
245
ToMoreStableChannel() const246 bool OmahaRequestParams::ToMoreStableChannel() const {
247 int current_channel_index = GetChannelIndex(image_props_.current_channel);
248 int download_channel_index = GetChannelIndex(download_channel_);
249
250 return download_channel_index > current_channel_index;
251 }
252
ShouldPowerwash() const253 bool OmahaRequestParams::ShouldPowerwash() const {
254 if (!mutable_image_props_.is_powerwash_allowed)
255 return false;
256 // If arbitrary channels are allowed, always powerwash on channel change.
257 if (image_props_.allow_arbitrary_channels)
258 return image_props_.current_channel != download_channel_;
259 // Otherwise only powerwash if we are moving from less stable (higher version)
260 // to more stable channel (lower version).
261 return ToMoreStableChannel();
262 }
263
GetAppId() const264 string OmahaRequestParams::GetAppId() const {
265 return download_channel_ == "canary-channel" ? image_props_.canary_product_id
266 : image_props_.product_id;
267 }
268
GetDlcAppId(const std::string & dlc_id) const269 string OmahaRequestParams::GetDlcAppId(const std::string& dlc_id) const {
270 // Create APP ID according to |dlc_id| (sticking the current AppID to the
271 // DLC module ID with an underscode).
272 return GetAppId() + "_" + dlc_id;
273 }
274
IsDlcAppId(const std::string & app_id) const275 bool OmahaRequestParams::IsDlcAppId(const std::string& app_id) const {
276 return dlc_apps_params().find(app_id) != dlc_apps_params().end();
277 }
278
GetDlcId(const string & app_id,string * dlc_id) const279 bool OmahaRequestParams::GetDlcId(const string& app_id, string* dlc_id) const {
280 auto itr = dlc_apps_params_.find(app_id);
281 if (itr == dlc_apps_params_.end())
282 return false;
283 *dlc_id = itr->second.name;
284 return true;
285 }
286
SetDlcNoUpdate(const string & app_id)287 void OmahaRequestParams::SetDlcNoUpdate(const string& app_id) {
288 auto itr = dlc_apps_params_.find(app_id);
289 if (itr == dlc_apps_params_.end())
290 return;
291 itr->second.updated = false;
292 }
293
294 } // namespace chromeos_update_engine
295