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