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 #include "update_engine/common_service.h"
18
19 #include <set>
20 #include <string>
21
22 #include <base/location.h>
23 #include <base/logging.h>
24 #include <base/strings/stringprintf.h>
25 #include <brillo/bind_lambda.h>
26 #include <brillo/message_loops/message_loop.h>
27 #include <brillo/strings/string_utils.h>
28 #include <policy/device_policy.h>
29
30 #include "update_engine/common/clock_interface.h"
31 #include "update_engine/common/hardware_interface.h"
32 #include "update_engine/common/prefs.h"
33 #include "update_engine/common/utils.h"
34 #include "update_engine/connection_manager_interface.h"
35 #include "update_engine/omaha_request_params.h"
36 #include "update_engine/omaha_utils.h"
37 #include "update_engine/p2p_manager.h"
38 #include "update_engine/payload_state_interface.h"
39 #include "update_engine/update_attempter.h"
40
41 using base::StringPrintf;
42 using brillo::ErrorPtr;
43 using brillo::string_utils::ToString;
44 using std::set;
45 using std::string;
46
47 namespace chromeos_update_engine {
48
49 namespace {
50 // Log and set the error on the passed ErrorPtr.
LogAndSetError(ErrorPtr * error,const tracked_objects::Location & location,const string & reason)51 void LogAndSetError(ErrorPtr* error,
52 const tracked_objects::Location& location,
53 const string& reason) {
54 brillo::Error::AddTo(error,
55 location,
56 UpdateEngineService::kErrorDomain,
57 UpdateEngineService::kErrorFailed,
58 reason);
59 LOG(ERROR) << "Sending Update Engine Failure: " << location.ToString() << ": "
60 << reason;
61 }
62 } // namespace
63
64 const char* const UpdateEngineService::kErrorDomain = "update_engine";
65 const char* const UpdateEngineService::kErrorFailed =
66 "org.chromium.UpdateEngine.Error.Failed";
67
UpdateEngineService(SystemState * system_state)68 UpdateEngineService::UpdateEngineService(SystemState* system_state)
69 : system_state_(system_state) {
70 }
71
72 // org::chromium::UpdateEngineInterfaceInterface methods implementation.
73
AttemptUpdate(ErrorPtr *,const string & in_app_version,const string & in_omaha_url,int32_t in_flags_as_int)74 bool UpdateEngineService::AttemptUpdate(ErrorPtr* /* error */,
75 const string& in_app_version,
76 const string& in_omaha_url,
77 int32_t in_flags_as_int) {
78 AttemptUpdateFlags flags = static_cast<AttemptUpdateFlags>(in_flags_as_int);
79 bool interactive = !(flags & kAttemptUpdateFlagNonInteractive);
80
81 LOG(INFO) << "Attempt update: app_version=\"" << in_app_version << "\" "
82 << "omaha_url=\"" << in_omaha_url << "\" "
83 << "flags=0x" << std::hex << flags << " "
84 << "interactive=" << (interactive ? "yes" : "no");
85 system_state_->update_attempter()->CheckForUpdate(
86 in_app_version, in_omaha_url, interactive);
87 return true;
88 }
89
AttemptRollback(ErrorPtr * error,bool in_powerwash)90 bool UpdateEngineService::AttemptRollback(ErrorPtr* error, bool in_powerwash) {
91 LOG(INFO) << "Attempting rollback to non-active partitions.";
92
93 if (!system_state_->update_attempter()->Rollback(in_powerwash)) {
94 // TODO(dgarrett): Give a more specific error code/reason.
95 LogAndSetError(error, FROM_HERE, "Rollback attempt failed.");
96 return false;
97 }
98 return true;
99 }
100
CanRollback(ErrorPtr *,bool * out_can_rollback)101 bool UpdateEngineService::CanRollback(ErrorPtr* /* error */,
102 bool* out_can_rollback) {
103 bool can_rollback = system_state_->update_attempter()->CanRollback();
104 LOG(INFO) << "Checking to see if we can rollback . Result: " << can_rollback;
105 *out_can_rollback = can_rollback;
106 return true;
107 }
108
ResetStatus(ErrorPtr * error)109 bool UpdateEngineService::ResetStatus(ErrorPtr* error) {
110 if (!system_state_->update_attempter()->ResetStatus()) {
111 // TODO(dgarrett): Give a more specific error code/reason.
112 LogAndSetError(error, FROM_HERE, "ResetStatus failed.");
113 return false;
114 }
115 return true;
116 }
117
GetStatus(ErrorPtr * error,int64_t * out_last_checked_time,double * out_progress,string * out_current_operation,string * out_new_version,int64_t * out_new_size)118 bool UpdateEngineService::GetStatus(ErrorPtr* error,
119 int64_t* out_last_checked_time,
120 double* out_progress,
121 string* out_current_operation,
122 string* out_new_version,
123 int64_t* out_new_size) {
124 if (!system_state_->update_attempter()->GetStatus(out_last_checked_time,
125 out_progress,
126 out_current_operation,
127 out_new_version,
128 out_new_size)) {
129 LogAndSetError(error, FROM_HERE, "GetStatus failed.");
130 return false;
131 }
132 return true;
133 }
134
RebootIfNeeded(ErrorPtr * error)135 bool UpdateEngineService::RebootIfNeeded(ErrorPtr* error) {
136 if (!system_state_->update_attempter()->RebootIfNeeded()) {
137 // TODO(dgarrett): Give a more specific error code/reason.
138 LogAndSetError(error, FROM_HERE, "Reboot not needed, or attempt failed.");
139 return false;
140 }
141 return true;
142 }
143
SetChannel(ErrorPtr * error,const string & in_target_channel,bool in_is_powerwash_allowed)144 bool UpdateEngineService::SetChannel(ErrorPtr* error,
145 const string& in_target_channel,
146 bool in_is_powerwash_allowed) {
147 const policy::DevicePolicy* device_policy = system_state_->device_policy();
148
149 // The device_policy is loaded in a lazy way before an update check. Load it
150 // now from the libbrillo cache if it wasn't already loaded.
151 if (!device_policy) {
152 UpdateAttempter* update_attempter = system_state_->update_attempter();
153 if (update_attempter) {
154 update_attempter->RefreshDevicePolicy();
155 device_policy = system_state_->device_policy();
156 }
157 }
158
159 bool delegated = false;
160 if (device_policy && device_policy->GetReleaseChannelDelegated(&delegated) &&
161 !delegated) {
162 LogAndSetError(error,
163 FROM_HERE,
164 "Cannot set target channel explicitly when channel "
165 "policy/settings is not delegated");
166 return false;
167 }
168
169 LOG(INFO) << "Setting destination channel to: " << in_target_channel;
170 string error_message;
171 if (!system_state_->request_params()->SetTargetChannel(
172 in_target_channel, in_is_powerwash_allowed, &error_message)) {
173 LogAndSetError(error, FROM_HERE, error_message);
174 return false;
175 }
176 // Update the weave state because updated the target channel.
177 system_state_->update_attempter()->BroadcastChannel();
178 return true;
179 }
180
GetChannel(ErrorPtr *,bool in_get_current_channel,string * out_channel)181 bool UpdateEngineService::GetChannel(ErrorPtr* /* error */,
182 bool in_get_current_channel,
183 string* out_channel) {
184 OmahaRequestParams* rp = system_state_->request_params();
185 *out_channel =
186 (in_get_current_channel ? rp->current_channel() : rp->target_channel());
187 return true;
188 }
189
SetCohortHint(ErrorPtr * error,string in_cohort_hint)190 bool UpdateEngineService::SetCohortHint(ErrorPtr* error,
191 string in_cohort_hint) {
192 PrefsInterface* prefs = system_state_->prefs();
193
194 // It is ok to override the cohort hint with an invalid value since it is
195 // stored in stateful partition. The code reading it should sanitize it
196 // anyway.
197 if (!prefs->SetString(kPrefsOmahaCohortHint, in_cohort_hint)) {
198 LogAndSetError(
199 error,
200 FROM_HERE,
201 StringPrintf("Error setting the cohort hint value to \"%s\".",
202 in_cohort_hint.c_str()));
203 return false;
204 }
205 return true;
206 }
207
GetCohortHint(ErrorPtr * error,string * out_cohort_hint)208 bool UpdateEngineService::GetCohortHint(ErrorPtr* error,
209 string* out_cohort_hint) {
210 PrefsInterface* prefs = system_state_->prefs();
211
212 *out_cohort_hint = "";
213 if (prefs->Exists(kPrefsOmahaCohortHint) &&
214 !prefs->GetString(kPrefsOmahaCohortHint, out_cohort_hint)) {
215 LogAndSetError(error, FROM_HERE, "Error getting the cohort hint.");
216 return false;
217 }
218 return true;
219 }
220
SetP2PUpdatePermission(ErrorPtr * error,bool in_enabled)221 bool UpdateEngineService::SetP2PUpdatePermission(ErrorPtr* error,
222 bool in_enabled) {
223 PrefsInterface* prefs = system_state_->prefs();
224
225 if (!prefs->SetBoolean(kPrefsP2PEnabled, in_enabled)) {
226 LogAndSetError(
227 error,
228 FROM_HERE,
229 StringPrintf("Error setting the update via p2p permission to %s.",
230 ToString(in_enabled).c_str()));
231 return false;
232 }
233 return true;
234 }
235
GetP2PUpdatePermission(ErrorPtr * error,bool * out_enabled)236 bool UpdateEngineService::GetP2PUpdatePermission(ErrorPtr* error,
237 bool* out_enabled) {
238 PrefsInterface* prefs = system_state_->prefs();
239
240 bool p2p_pref = false; // Default if no setting is present.
241 if (prefs->Exists(kPrefsP2PEnabled) &&
242 !prefs->GetBoolean(kPrefsP2PEnabled, &p2p_pref)) {
243 LogAndSetError(error, FROM_HERE, "Error getting the P2PEnabled setting.");
244 return false;
245 }
246
247 *out_enabled = p2p_pref;
248 return true;
249 }
250
SetUpdateOverCellularPermission(ErrorPtr * error,bool in_allowed)251 bool UpdateEngineService::SetUpdateOverCellularPermission(ErrorPtr* error,
252 bool in_allowed) {
253 set<string> allowed_types;
254 const policy::DevicePolicy* device_policy = system_state_->device_policy();
255
256 // The device_policy is loaded in a lazy way before an update check. Load it
257 // now from the libbrillo cache if it wasn't already loaded.
258 if (!device_policy) {
259 UpdateAttempter* update_attempter = system_state_->update_attempter();
260 if (update_attempter) {
261 update_attempter->RefreshDevicePolicy();
262 device_policy = system_state_->device_policy();
263 }
264 }
265
266 // Check if this setting is allowed by the device policy.
267 if (device_policy &&
268 device_policy->GetAllowedConnectionTypesForUpdate(&allowed_types)) {
269 LogAndSetError(error,
270 FROM_HERE,
271 "Ignoring the update over cellular setting since there's "
272 "a device policy enforcing this setting.");
273 return false;
274 }
275
276 // If the policy wasn't loaded yet, then it is still OK to change the local
277 // setting because the policy will be checked again during the update check.
278
279 PrefsInterface* prefs = system_state_->prefs();
280
281 if (!prefs->SetBoolean(kPrefsUpdateOverCellularPermission, in_allowed)) {
282 LogAndSetError(error,
283 FROM_HERE,
284 string("Error setting the update over cellular to ") +
285 (in_allowed ? "true" : "false"));
286 return false;
287 }
288 return true;
289 }
290
GetUpdateOverCellularPermission(ErrorPtr *,bool * out_allowed)291 bool UpdateEngineService::GetUpdateOverCellularPermission(ErrorPtr* /* error */,
292 bool* out_allowed) {
293 ConnectionManagerInterface* cm = system_state_->connection_manager();
294
295 // The device_policy is loaded in a lazy way before an update check and is
296 // used to determine if an update is allowed over cellular. Load the device
297 // policy now from the libbrillo cache if it wasn't already loaded.
298 if (!system_state_->device_policy()) {
299 UpdateAttempter* update_attempter = system_state_->update_attempter();
300 if (update_attempter)
301 update_attempter->RefreshDevicePolicy();
302 }
303
304 // Return the current setting based on the same logic used while checking for
305 // updates. A log message could be printed as the result of this test.
306 LOG(INFO) << "Checking if updates over cellular networks are allowed:";
307 *out_allowed = cm->IsUpdateAllowedOver(ConnectionType::kCellular,
308 ConnectionTethering::kUnknown);
309 return true;
310 }
311
GetDurationSinceUpdate(ErrorPtr * error,int64_t * out_usec_wallclock)312 bool UpdateEngineService::GetDurationSinceUpdate(ErrorPtr* error,
313 int64_t* out_usec_wallclock) {
314 base::Time time;
315 if (!system_state_->update_attempter()->GetBootTimeAtUpdate(&time)) {
316 LogAndSetError(error, FROM_HERE, "No pending update.");
317 return false;
318 }
319
320 ClockInterface* clock = system_state_->clock();
321 *out_usec_wallclock = (clock->GetBootTime() - time).InMicroseconds();
322 return true;
323 }
324
GetPrevVersion(ErrorPtr *,string * out_prev_version)325 bool UpdateEngineService::GetPrevVersion(ErrorPtr* /* error */,
326 string* out_prev_version) {
327 *out_prev_version = system_state_->update_attempter()->GetPrevVersion();
328 return true;
329 }
330
GetRollbackPartition(ErrorPtr *,string * out_rollback_partition_name)331 bool UpdateEngineService::GetRollbackPartition(
332 ErrorPtr* /* error */, string* out_rollback_partition_name) {
333 BootControlInterface::Slot rollback_slot =
334 system_state_->update_attempter()->GetRollbackSlot();
335
336 if (rollback_slot == BootControlInterface::kInvalidSlot) {
337 out_rollback_partition_name->clear();
338 return true;
339 }
340
341 string name;
342 if (!system_state_->boot_control()->GetPartitionDevice(
343 "KERNEL", rollback_slot, &name)) {
344 LOG(ERROR) << "Invalid rollback device";
345 return false;
346 }
347
348 LOG(INFO) << "Getting rollback partition name. Result: " << name;
349 *out_rollback_partition_name = name;
350 return true;
351 }
352
GetLastAttemptError(ErrorPtr *,int32_t * out_last_attempt_error)353 bool UpdateEngineService::GetLastAttemptError(ErrorPtr* /* error */,
354 int32_t* out_last_attempt_error) {
355 ErrorCode error_code = system_state_->payload_state()->GetAttemptErrorCode();
356 *out_last_attempt_error = static_cast<int>(error_code);
357 return true;
358 }
359
GetEolStatus(ErrorPtr * error,int32_t * out_eol_status)360 bool UpdateEngineService::GetEolStatus(ErrorPtr* error,
361 int32_t* out_eol_status) {
362 PrefsInterface* prefs = system_state_->prefs();
363
364 string str_eol_status;
365 if (prefs->Exists(kPrefsOmahaEolStatus) &&
366 !prefs->GetString(kPrefsOmahaEolStatus, &str_eol_status)) {
367 LogAndSetError(error, FROM_HERE, "Error getting the end-of-life status.");
368 return false;
369 }
370
371 // StringToEolStatus will return kSupported for invalid values.
372 *out_eol_status = static_cast<int32_t>(StringToEolStatus(str_eol_status));
373 return true;
374 }
375
376 } // namespace chromeos_update_engine
377