update_attempter.cc revision d6deb1d0357f47d5525bfaeffa6c201b19abd3e7 
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/update_attempter.h"
18
19#include <stdint.h>
20
21#include <algorithm>
22#include <memory>
23#include <set>
24#include <string>
25#include <utility>
26#include <vector>
27
28#include <base/bind.h>
29#include <base/files/file_util.h>
30#include <base/logging.h>
31#include <base/rand_util.h>
32#include <base/strings/string_util.h>
33#include <base/strings/stringprintf.h>
34#include <chromeos/bind_lambda.h>
35#include <chromeos/message_loops/message_loop.h>
36#include <debugd/dbus-constants.h>
37#include <metrics/metrics_library.h>
38#include <policy/device_policy.h>
39#include <policy/libpolicy.h>
40#include <power_manager/dbus-constants.h>
41#include <power_manager/dbus-proxies.h>
42#include <update_engine/dbus-constants.h>
43
44#include "update_engine/certificate_checker.h"
45#include "update_engine/clock_interface.h"
46#include "update_engine/constants.h"
47#include "update_engine/dbus_service.h"
48#include "update_engine/download_action.h"
49#include "update_engine/filesystem_verifier_action.h"
50#include "update_engine/hardware_interface.h"
51#include "update_engine/libcurl_http_fetcher.h"
52#include "update_engine/metrics.h"
53#include "update_engine/multi_range_http_fetcher.h"
54#include "update_engine/omaha_request_action.h"
55#include "update_engine/omaha_request_params.h"
56#include "update_engine/omaha_response_handler_action.h"
57#include "update_engine/p2p_manager.h"
58#include "update_engine/payload_state_interface.h"
59#include "update_engine/postinstall_runner_action.h"
60#include "update_engine/prefs_interface.h"
61#include "update_engine/subprocess.h"
62#include "update_engine/system_state.h"
63#include "update_engine/update_manager/policy.h"
64#include "update_engine/update_manager/update_manager.h"
65#include "update_engine/utils.h"
66
67using base::Bind;
68using base::Callback;
69using base::StringPrintf;
70using base::Time;
71using base::TimeDelta;
72using base::TimeTicks;
73using chromeos::MessageLoop;
74using chromeos_update_manager::EvalStatus;
75using chromeos_update_manager::Policy;
76using chromeos_update_manager::UpdateCheckParams;
77using std::set;
78using std::shared_ptr;
79using std::string;
80using std::vector;
81
82namespace chromeos_update_engine {
83
84const int UpdateAttempter::kMaxDeltaUpdateFailures = 3;
85
86namespace {
87const int kMaxConsecutiveObeyProxyRequests = 20;
88
89const char kUpdateCompletedMarker[] =
90    "/var/run/update_engine_autoupdate_completed";
91
92// By default autest bypasses scattering. If we want to test scattering,
93// use kScheduledAUTestURLRequest. The URL used is same in both cases, but
94// different params are passed to CheckForUpdate().
95const char kAUTestURLRequest[] = "autest";
96const char kScheduledAUTestURLRequest[] = "autest-scheduled";
97}  // namespace
98
99const char* UpdateStatusToString(UpdateStatus status) {
100  switch (status) {
101    case UPDATE_STATUS_IDLE:
102      return update_engine::kUpdateStatusIdle;
103    case UPDATE_STATUS_CHECKING_FOR_UPDATE:
104      return update_engine::kUpdateStatusCheckingForUpdate;
105    case UPDATE_STATUS_UPDATE_AVAILABLE:
106      return update_engine::kUpdateStatusUpdateAvailable;
107    case UPDATE_STATUS_DOWNLOADING:
108      return update_engine::kUpdateStatusDownloading;
109    case UPDATE_STATUS_VERIFYING:
110      return update_engine::kUpdateStatusVerifying;
111    case UPDATE_STATUS_FINALIZING:
112      return update_engine::kUpdateStatusFinalizing;
113    case UPDATE_STATUS_UPDATED_NEED_REBOOT:
114      return update_engine::kUpdateStatusUpdatedNeedReboot;
115    case UPDATE_STATUS_REPORTING_ERROR_EVENT:
116      return update_engine::kUpdateStatusReportingErrorEvent;
117    case UPDATE_STATUS_ATTEMPTING_ROLLBACK:
118      return update_engine::kUpdateStatusAttemptingRollback;
119    case UPDATE_STATUS_DISABLED:
120      return update_engine::kUpdateStatusDisabled;
121    default:
122      return "unknown status";
123  }
124}
125
126// Turns a generic ErrorCode::kError to a generic error code specific
127// to |action| (e.g., ErrorCode::kFilesystemVerifierError). If |code| is
128// not ErrorCode::kError, or the action is not matched, returns |code|
129// unchanged.
130ErrorCode GetErrorCodeForAction(AbstractAction* action,
131                                     ErrorCode code) {
132  if (code != ErrorCode::kError)
133    return code;
134
135  const string type = action->Type();
136  if (type == OmahaRequestAction::StaticType())
137    return ErrorCode::kOmahaRequestError;
138  if (type == OmahaResponseHandlerAction::StaticType())
139    return ErrorCode::kOmahaResponseHandlerError;
140  if (type == FilesystemVerifierAction::StaticType())
141    return ErrorCode::kFilesystemVerifierError;
142  if (type == PostinstallRunnerAction::StaticType())
143    return ErrorCode::kPostinstallRunnerError;
144
145  return code;
146}
147
148UpdateAttempter::UpdateAttempter(
149    SystemState* system_state,
150    LibCrosProxy* libcros_proxy,
151    org::chromium::debugdProxyInterface* debugd_proxy)
152    : UpdateAttempter(system_state, libcros_proxy, debugd_proxy,
153                      kUpdateCompletedMarker) {}
154
155UpdateAttempter::UpdateAttempter(
156    SystemState* system_state,
157    LibCrosProxy* libcros_proxy,
158    org::chromium::debugdProxyInterface* debugd_proxy,
159    const string& update_completed_marker)
160    : processor_(new ActionProcessor()),
161      system_state_(system_state),
162      chrome_proxy_resolver_(libcros_proxy),
163      update_completed_marker_(update_completed_marker),
164      debugd_proxy_(debugd_proxy) {
165  if (!update_completed_marker_.empty() &&
166      utils::FileExists(update_completed_marker_.c_str())) {
167    status_ = UPDATE_STATUS_UPDATED_NEED_REBOOT;
168  } else {
169    status_ = UPDATE_STATUS_IDLE;
170  }
171}
172
173UpdateAttempter::~UpdateAttempter() {
174  CleanupCpuSharesManagement();
175}
176
177void UpdateAttempter::Init() {
178  // Pulling from the SystemState can only be done after construction, since
179  // this is an aggregate of various objects (such as the UpdateAttempter),
180  // which requires them all to be constructed prior to it being used.
181  prefs_ = system_state_->prefs();
182  omaha_request_params_ = system_state_->request_params();
183}
184
185void UpdateAttempter::ScheduleUpdates() {
186  if (IsUpdateRunningOrScheduled())
187    return;
188
189  chromeos_update_manager::UpdateManager* const update_manager =
190      system_state_->update_manager();
191  CHECK(update_manager);
192  Callback<void(EvalStatus, const UpdateCheckParams&)> callback = Bind(
193      &UpdateAttempter::OnUpdateScheduled, base::Unretained(this));
194  // We limit the async policy request to a reasonably short time, to avoid a
195  // starvation due to a transient bug.
196  update_manager->AsyncPolicyRequest(callback, &Policy::UpdateCheckAllowed);
197  waiting_for_scheduled_check_ = true;
198}
199
200bool UpdateAttempter::CheckAndReportDailyMetrics() {
201  int64_t stored_value;
202  Time now = system_state_->clock()->GetWallclockTime();
203  if (system_state_->prefs()->Exists(kPrefsDailyMetricsLastReportedAt) &&
204      system_state_->prefs()->GetInt64(kPrefsDailyMetricsLastReportedAt,
205                                       &stored_value)) {
206    Time last_reported_at = Time::FromInternalValue(stored_value);
207    TimeDelta time_reported_since = now - last_reported_at;
208    if (time_reported_since.InSeconds() < 0) {
209      LOG(WARNING) << "Last reported daily metrics "
210                   << utils::FormatTimeDelta(time_reported_since) << " ago "
211                   << "which is negative. Either the system clock is wrong or "
212                   << "the kPrefsDailyMetricsLastReportedAt state variable "
213                   << "is wrong.";
214      // In this case, report daily metrics to reset.
215    } else {
216      if (time_reported_since.InSeconds() < 24*60*60) {
217        LOG(INFO) << "Last reported daily metrics "
218                  << utils::FormatTimeDelta(time_reported_since) << " ago.";
219        return false;
220      }
221      LOG(INFO) << "Last reported daily metrics "
222                << utils::FormatTimeDelta(time_reported_since) << " ago, "
223                << "which is more than 24 hours ago.";
224    }
225  }
226
227  LOG(INFO) << "Reporting daily metrics.";
228  system_state_->prefs()->SetInt64(kPrefsDailyMetricsLastReportedAt,
229                                   now.ToInternalValue());
230
231  ReportOSAge();
232
233  return true;
234}
235
236void UpdateAttempter::ReportOSAge() {
237  struct stat sb;
238
239  if (system_state_ == nullptr)
240    return;
241
242  if (stat("/etc/lsb-release", &sb) != 0) {
243    PLOG(ERROR) << "Error getting file status for /etc/lsb-release "
244                << "(Note: this may happen in some unit tests)";
245    return;
246  }
247
248  Time lsb_release_timestamp = utils::TimeFromStructTimespec(&sb.st_ctim);
249  Time now = system_state_->clock()->GetWallclockTime();
250  TimeDelta age = now - lsb_release_timestamp;
251  if (age.InSeconds() < 0) {
252    LOG(ERROR) << "The OS age (" << utils::FormatTimeDelta(age)
253               << ") is negative. Maybe the clock is wrong? "
254               << "(Note: this may happen in some unit tests.)";
255    return;
256  }
257
258  string metric = "Installer.OSAgeDays";
259  LOG(INFO) << "Uploading " << utils::FormatTimeDelta(age)
260            << " for metric " <<  metric;
261  system_state_->metrics_lib()->SendToUMA(
262       metric,
263       static_cast<int>(age.InDays()),
264       0,             // min: 0 days
265       6*30,          // max: 6 months (approx)
266       kNumDefaultUmaBuckets);
267
268  metrics::ReportDailyMetrics(system_state_, age);
269}
270
271void UpdateAttempter::Update(const string& app_version,
272                             const string& omaha_url,
273                             const string& target_channel,
274                             const string& target_version_prefix,
275                             bool obey_proxies,
276                             bool interactive) {
277  // This is normally called frequently enough so it's appropriate to use as a
278  // hook for reporting daily metrics.
279  // TODO(garnold) This should be hooked to a separate (reliable and consistent)
280  // timeout event.
281  CheckAndReportDailyMetrics();
282
283  // Notify of the new update attempt, clearing prior interactive requests.
284  if (forced_update_pending_callback_.get())
285    forced_update_pending_callback_->Run(false, false);
286
287  chrome_proxy_resolver_.Init();
288  fake_update_success_ = false;
289  if (status_ == UPDATE_STATUS_UPDATED_NEED_REBOOT) {
290    // Although we have applied an update, we still want to ping Omaha
291    // to ensure the number of active statistics is accurate.
292    //
293    // Also convey to the UpdateEngine.Check.Result metric that we're
294    // not performing an update check because of this.
295    LOG(INFO) << "Not updating b/c we already updated and we're waiting for "
296              << "reboot, we'll ping Omaha instead";
297    metrics::ReportUpdateCheckMetrics(system_state_,
298                                      metrics::CheckResult::kRebootPending,
299                                      metrics::CheckReaction::kUnset,
300                                      metrics::DownloadErrorCode::kUnset);
301    PingOmaha();
302    return;
303  }
304  if (status_ != UPDATE_STATUS_IDLE) {
305    // Update in progress. Do nothing
306    return;
307  }
308
309  if (!CalculateUpdateParams(app_version,
310                             omaha_url,
311                             target_channel,
312                             target_version_prefix,
313                             obey_proxies,
314                             interactive)) {
315    return;
316  }
317
318  BuildUpdateActions(interactive);
319
320  SetStatusAndNotify(UPDATE_STATUS_CHECKING_FOR_UPDATE);
321
322  // Update the last check time here; it may be re-updated when an Omaha
323  // response is received, but this will prevent us from repeatedly scheduling
324  // checks in the case where a response is not received.
325  UpdateLastCheckedTime();
326
327  // Just in case we didn't update boot flags yet, make sure they're updated
328  // before any update processing starts.
329  start_action_processor_ = true;
330  UpdateBootFlags();
331}
332
333void UpdateAttempter::RefreshDevicePolicy() {
334  // Lazy initialize the policy provider, or reload the latest policy data.
335  if (!policy_provider_.get())
336    policy_provider_.reset(new policy::PolicyProvider());
337  policy_provider_->Reload();
338
339  const policy::DevicePolicy* device_policy = nullptr;
340  if (policy_provider_->device_policy_is_loaded())
341    device_policy = &policy_provider_->GetDevicePolicy();
342
343  if (device_policy)
344    LOG(INFO) << "Device policies/settings present";
345  else
346    LOG(INFO) << "No device policies/settings present.";
347
348  system_state_->set_device_policy(device_policy);
349  system_state_->p2p_manager()->SetDevicePolicy(device_policy);
350}
351
352void UpdateAttempter::CalculateP2PParams(bool interactive) {
353  bool use_p2p_for_downloading = false;
354  bool use_p2p_for_sharing = false;
355
356  // Never use p2p for downloading in interactive checks unless the
357  // developer has opted in for it via a marker file.
358  //
359  // (Why would a developer want to opt in? If he's working on the
360  // update_engine or p2p codebases so he can actually test his
361  // code.).
362
363  if (system_state_ != nullptr) {
364    if (!system_state_->p2p_manager()->IsP2PEnabled()) {
365      LOG(INFO) << "p2p is not enabled - disallowing p2p for both"
366                << " downloading and sharing.";
367    } else {
368      // Allow p2p for sharing, even in interactive checks.
369      use_p2p_for_sharing = true;
370      if (!interactive) {
371        LOG(INFO) << "Non-interactive check - allowing p2p for downloading";
372        use_p2p_for_downloading = true;
373      } else {
374        LOG(INFO) << "Forcibly disabling use of p2p for downloading "
375                  << "since this update attempt is interactive.";
376      }
377    }
378  }
379
380  PayloadStateInterface* const payload_state = system_state_->payload_state();
381  payload_state->SetUsingP2PForDownloading(use_p2p_for_downloading);
382  payload_state->SetUsingP2PForSharing(use_p2p_for_sharing);
383}
384
385bool UpdateAttempter::CalculateUpdateParams(const string& app_version,
386                                            const string& omaha_url,
387                                            const string& target_channel,
388                                            const string& target_version_prefix,
389                                            bool obey_proxies,
390                                            bool interactive) {
391  http_response_code_ = 0;
392  PayloadStateInterface* const payload_state = system_state_->payload_state();
393
394  // Refresh the policy before computing all the update parameters.
395  RefreshDevicePolicy();
396
397  // Set the target version prefix, if provided.
398  if (!target_version_prefix.empty())
399    omaha_request_params_->set_target_version_prefix(target_version_prefix);
400
401  CalculateScatteringParams(interactive);
402
403  CalculateP2PParams(interactive);
404  if (payload_state->GetUsingP2PForDownloading() ||
405      payload_state->GetUsingP2PForSharing()) {
406    // OK, p2p is to be used - start it and perform housekeeping.
407    if (!StartP2PAndPerformHousekeeping()) {
408      // If this fails, disable p2p for this attempt
409      LOG(INFO) << "Forcibly disabling use of p2p since starting p2p or "
410                << "performing housekeeping failed.";
411      payload_state->SetUsingP2PForDownloading(false);
412      payload_state->SetUsingP2PForSharing(false);
413    }
414  }
415
416  if (!omaha_request_params_->Init(app_version,
417                                   omaha_url,
418                                   interactive)) {
419    LOG(ERROR) << "Unable to initialize Omaha request params.";
420    return false;
421  }
422
423  // Set the target channel, if one was provided.
424  if (target_channel.empty()) {
425    LOG(INFO) << "No target channel mandated by policy.";
426  } else {
427    LOG(INFO) << "Setting target channel as mandated: " << target_channel;
428    // Pass in false for powerwash_allowed until we add it to the policy
429    // protobuf.
430    omaha_request_params_->SetTargetChannel(target_channel, false);
431
432    // Since this is the beginning of a new attempt, update the download
433    // channel. The download channel won't be updated until the next attempt,
434    // even if target channel changes meanwhile, so that how we'll know if we
435    // should cancel the current download attempt if there's such a change in
436    // target channel.
437    omaha_request_params_->UpdateDownloadChannel();
438  }
439
440  LOG(INFO) << "target_version_prefix = "
441            << omaha_request_params_->target_version_prefix()
442            << ", scatter_factor_in_seconds = "
443            << utils::FormatSecs(scatter_factor_.InSeconds());
444
445  LOG(INFO) << "Wall Clock Based Wait Enabled = "
446            << omaha_request_params_->wall_clock_based_wait_enabled()
447            << ", Update Check Count Wait Enabled = "
448            << omaha_request_params_->update_check_count_wait_enabled()
449            << ", Waiting Period = " << utils::FormatSecs(
450               omaha_request_params_->waiting_period().InSeconds());
451
452  LOG(INFO) << "Use p2p For Downloading = "
453            << payload_state->GetUsingP2PForDownloading()
454            << ", Use p2p For Sharing = "
455            << payload_state->GetUsingP2PForSharing();
456
457  obeying_proxies_ = true;
458  if (obey_proxies || proxy_manual_checks_ == 0) {
459    LOG(INFO) << "forced to obey proxies";
460    // If forced to obey proxies, every 20th request will not use proxies
461    proxy_manual_checks_++;
462    LOG(INFO) << "proxy manual checks: " << proxy_manual_checks_;
463    if (proxy_manual_checks_ >= kMaxConsecutiveObeyProxyRequests) {
464      proxy_manual_checks_ = 0;
465      obeying_proxies_ = false;
466    }
467  } else if (base::RandInt(0, 4) == 0) {
468    obeying_proxies_ = false;
469  }
470  LOG_IF(INFO, !obeying_proxies_) << "To help ensure updates work, this update "
471      "check we are ignoring the proxy settings and using "
472      "direct connections.";
473
474  DisableDeltaUpdateIfNeeded();
475  return true;
476}
477
478void UpdateAttempter::CalculateScatteringParams(bool interactive) {
479  // Take a copy of the old scatter value before we update it, as
480  // we need to update the waiting period if this value changes.
481  TimeDelta old_scatter_factor = scatter_factor_;
482  const policy::DevicePolicy* device_policy = system_state_->device_policy();
483  if (device_policy) {
484    int64_t new_scatter_factor_in_secs = 0;
485    device_policy->GetScatterFactorInSeconds(&new_scatter_factor_in_secs);
486    if (new_scatter_factor_in_secs < 0)  // sanitize input, just in case.
487      new_scatter_factor_in_secs  = 0;
488    scatter_factor_ = TimeDelta::FromSeconds(new_scatter_factor_in_secs);
489  }
490
491  bool is_scatter_enabled = false;
492  if (scatter_factor_.InSeconds() == 0) {
493    LOG(INFO) << "Scattering disabled since scatter factor is set to 0";
494  } else if (interactive) {
495    LOG(INFO) << "Scattering disabled as this is an interactive update check";
496  } else if (!system_state_->hardware()->IsOOBEComplete(nullptr)) {
497    LOG(INFO) << "Scattering disabled since OOBE is not complete yet";
498  } else {
499    is_scatter_enabled = true;
500    LOG(INFO) << "Scattering is enabled";
501  }
502
503  if (is_scatter_enabled) {
504    // This means the scattering policy is turned on.
505    // Now check if we need to update the waiting period. The two cases
506    // in which we'd need to update the waiting period are:
507    // 1. First time in process or a scheduled check after a user-initiated one.
508    //    (omaha_request_params_->waiting_period will be zero in this case).
509    // 2. Admin has changed the scattering policy value.
510    //    (new scattering value will be different from old one in this case).
511    int64_t wait_period_in_secs = 0;
512    if (omaha_request_params_->waiting_period().InSeconds() == 0) {
513      // First case. Check if we have a suitable value to set for
514      // the waiting period.
515      if (prefs_->GetInt64(kPrefsWallClockWaitPeriod, &wait_period_in_secs) &&
516          wait_period_in_secs > 0 &&
517          wait_period_in_secs <= scatter_factor_.InSeconds()) {
518        // This means:
519        // 1. There's a persisted value for the waiting period available.
520        // 2. And that persisted value is still valid.
521        // So, in this case, we should reuse the persisted value instead of
522        // generating a new random value to improve the chances of a good
523        // distribution for scattering.
524        omaha_request_params_->set_waiting_period(
525          TimeDelta::FromSeconds(wait_period_in_secs));
526        LOG(INFO) << "Using persisted wall-clock waiting period: " <<
527            utils::FormatSecs(
528                omaha_request_params_->waiting_period().InSeconds());
529      } else {
530        // This means there's no persisted value for the waiting period
531        // available or its value is invalid given the new scatter_factor value.
532        // So, we should go ahead and regenerate a new value for the
533        // waiting period.
534        LOG(INFO) << "Persisted value not present or not valid ("
535                  << utils::FormatSecs(wait_period_in_secs)
536                  << ") for wall-clock waiting period.";
537        GenerateNewWaitingPeriod();
538      }
539    } else if (scatter_factor_ != old_scatter_factor) {
540      // This means there's already a waiting period value, but we detected
541      // a change in the scattering policy value. So, we should regenerate the
542      // waiting period to make sure it's within the bounds of the new scatter
543      // factor value.
544      GenerateNewWaitingPeriod();
545    } else {
546      // Neither the first time scattering is enabled nor the scattering value
547      // changed. Nothing to do.
548      LOG(INFO) << "Keeping current wall-clock waiting period: " <<
549          utils::FormatSecs(
550              omaha_request_params_->waiting_period().InSeconds());
551    }
552
553    // The invariant at this point is that omaha_request_params_->waiting_period
554    // is non-zero no matter which path we took above.
555    LOG_IF(ERROR, omaha_request_params_->waiting_period().InSeconds() == 0)
556        << "Waiting Period should NOT be zero at this point!!!";
557
558    // Since scattering is enabled, wall clock based wait will always be
559    // enabled.
560    omaha_request_params_->set_wall_clock_based_wait_enabled(true);
561
562    // If we don't have any issues in accessing the file system to update
563    // the update check count value, we'll turn that on as well.
564    bool decrement_succeeded = DecrementUpdateCheckCount();
565    omaha_request_params_->set_update_check_count_wait_enabled(
566      decrement_succeeded);
567  } else {
568    // This means the scattering feature is turned off or disabled for
569    // this particular update check. Make sure to disable
570    // all the knobs and artifacts so that we don't invoke any scattering
571    // related code.
572    omaha_request_params_->set_wall_clock_based_wait_enabled(false);
573    omaha_request_params_->set_update_check_count_wait_enabled(false);
574    omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds(0));
575    prefs_->Delete(kPrefsWallClockWaitPeriod);
576    prefs_->Delete(kPrefsUpdateCheckCount);
577    // Don't delete the UpdateFirstSeenAt file as we don't want manual checks
578    // that result in no-updates (e.g. due to server side throttling) to
579    // cause update starvation by having the client generate a new
580    // UpdateFirstSeenAt for each scheduled check that follows a manual check.
581  }
582}
583
584void UpdateAttempter::GenerateNewWaitingPeriod() {
585  omaha_request_params_->set_waiting_period(TimeDelta::FromSeconds(
586      base::RandInt(1, scatter_factor_.InSeconds())));
587
588  LOG(INFO) << "Generated new wall-clock waiting period: " << utils::FormatSecs(
589                omaha_request_params_->waiting_period().InSeconds());
590
591  // Do a best-effort to persist this in all cases. Even if the persistence
592  // fails, we'll still be able to scatter based on our in-memory value.
593  // The persistence only helps in ensuring a good overall distribution
594  // across multiple devices if they tend to reboot too often.
595  system_state_->payload_state()->SetScatteringWaitPeriod(
596      omaha_request_params_->waiting_period());
597}
598
599void UpdateAttempter::BuildPostInstallActions(
600    InstallPlanAction* previous_action) {
601  shared_ptr<PostinstallRunnerAction> postinstall_runner_action(
602        new PostinstallRunnerAction());
603  actions_.push_back(shared_ptr<AbstractAction>(postinstall_runner_action));
604  BondActions(previous_action,
605              postinstall_runner_action.get());
606}
607
608void UpdateAttempter::BuildUpdateActions(bool interactive) {
609  CHECK(!processor_->IsRunning());
610  processor_->set_delegate(this);
611
612  // Actions:
613  LibcurlHttpFetcher* update_check_fetcher =
614      new LibcurlHttpFetcher(GetProxyResolver(), system_state_);
615  // Try harder to connect to the network, esp when not interactive.
616  // See comment in libcurl_http_fetcher.cc.
617  update_check_fetcher->set_no_network_max_retries(interactive ? 1 : 3);
618  update_check_fetcher->set_check_certificate(CertificateChecker::kUpdate);
619  shared_ptr<OmahaRequestAction> update_check_action(
620      new OmahaRequestAction(system_state_,
621                             nullptr,
622                             update_check_fetcher,  // passes ownership
623                             false));
624  shared_ptr<OmahaResponseHandlerAction> response_handler_action(
625      new OmahaResponseHandlerAction(system_state_));
626  shared_ptr<FilesystemVerifierAction> src_filesystem_verifier_action(
627      new FilesystemVerifierAction(system_state_,
628                                   PartitionType::kSourceRootfs));
629  shared_ptr<FilesystemVerifierAction> src_kernel_filesystem_verifier_action(
630      new FilesystemVerifierAction(system_state_,
631                                   PartitionType::kSourceKernel));
632
633  shared_ptr<OmahaRequestAction> download_started_action(
634      new OmahaRequestAction(system_state_,
635                             new OmahaEvent(
636                                 OmahaEvent::kTypeUpdateDownloadStarted),
637                             new LibcurlHttpFetcher(GetProxyResolver(),
638                                                    system_state_),
639                             false));
640  LibcurlHttpFetcher* download_fetcher =
641      new LibcurlHttpFetcher(GetProxyResolver(), system_state_);
642  download_fetcher->set_check_certificate(CertificateChecker::kDownload);
643  shared_ptr<DownloadAction> download_action(
644      new DownloadAction(prefs_,
645                         system_state_,
646                         new MultiRangeHttpFetcher(
647                             download_fetcher)));  // passes ownership
648  shared_ptr<OmahaRequestAction> download_finished_action(
649      new OmahaRequestAction(system_state_,
650                             new OmahaEvent(
651                                 OmahaEvent::kTypeUpdateDownloadFinished),
652                             new LibcurlHttpFetcher(GetProxyResolver(),
653                                                    system_state_),
654                             false));
655  shared_ptr<FilesystemVerifierAction> dst_filesystem_verifier_action(
656      new FilesystemVerifierAction(system_state_, PartitionType::kRootfs));
657  shared_ptr<FilesystemVerifierAction> dst_kernel_filesystem_verifier_action(
658      new FilesystemVerifierAction(system_state_, PartitionType::kKernel));
659  shared_ptr<OmahaRequestAction> update_complete_action(
660      new OmahaRequestAction(system_state_,
661                             new OmahaEvent(OmahaEvent::kTypeUpdateComplete),
662                             new LibcurlHttpFetcher(GetProxyResolver(),
663                                                    system_state_),
664                             false));
665
666  download_action->set_delegate(this);
667  response_handler_action_ = response_handler_action;
668  download_action_ = download_action;
669
670  actions_.push_back(shared_ptr<AbstractAction>(update_check_action));
671  actions_.push_back(shared_ptr<AbstractAction>(response_handler_action));
672  actions_.push_back(shared_ptr<AbstractAction>(
673      src_filesystem_verifier_action));
674  actions_.push_back(shared_ptr<AbstractAction>(
675      src_kernel_filesystem_verifier_action));
676  actions_.push_back(shared_ptr<AbstractAction>(download_started_action));
677  actions_.push_back(shared_ptr<AbstractAction>(download_action));
678  actions_.push_back(shared_ptr<AbstractAction>(download_finished_action));
679  actions_.push_back(shared_ptr<AbstractAction>(
680      dst_filesystem_verifier_action));
681  actions_.push_back(shared_ptr<AbstractAction>(
682      dst_kernel_filesystem_verifier_action));
683
684  // Bond them together. We have to use the leaf-types when calling
685  // BondActions().
686  BondActions(update_check_action.get(),
687              response_handler_action.get());
688  BondActions(response_handler_action.get(),
689              src_filesystem_verifier_action.get());
690  BondActions(src_filesystem_verifier_action.get(),
691              src_kernel_filesystem_verifier_action.get());
692  BondActions(src_kernel_filesystem_verifier_action.get(),
693              download_action.get());
694  BondActions(download_action.get(),
695              dst_filesystem_verifier_action.get());
696  BondActions(dst_filesystem_verifier_action.get(),
697              dst_kernel_filesystem_verifier_action.get());
698
699  BuildPostInstallActions(dst_kernel_filesystem_verifier_action.get());
700
701  actions_.push_back(shared_ptr<AbstractAction>(update_complete_action));
702
703  // Enqueue the actions
704  for (const shared_ptr<AbstractAction>& action : actions_) {
705    processor_->EnqueueAction(action.get());
706  }
707}
708
709bool UpdateAttempter::Rollback(bool powerwash) {
710  if (!CanRollback()) {
711    return false;
712  }
713
714  // Extra check for enterprise-enrolled devices since they don't support
715  // powerwash.
716  if (powerwash) {
717    // Enterprise-enrolled devices have an empty owner in their device policy.
718    string owner;
719    RefreshDevicePolicy();
720    const policy::DevicePolicy* device_policy = system_state_->device_policy();
721    if (device_policy && (!device_policy->GetOwner(&owner) || owner.empty())) {
722      LOG(ERROR) << "Enterprise device detected. "
723                 << "Cannot perform a powerwash for enterprise devices.";
724      return false;
725    }
726  }
727
728  processor_->set_delegate(this);
729
730  // Initialize the default request params.
731  if (!omaha_request_params_->Init("", "", true)) {
732    LOG(ERROR) << "Unable to initialize Omaha request params.";
733    return false;
734  }
735
736  LOG(INFO) << "Setting rollback options.";
737  InstallPlan install_plan;
738
739  install_plan.target_slot = GetRollbackSlot();
740  install_plan.source_slot = system_state_->boot_control()->GetCurrentSlot();
741
742  TEST_AND_RETURN_FALSE(install_plan.LoadPartitionsFromSlots(system_state_));
743  install_plan.powerwash_required = powerwash;
744
745  LOG(INFO) << "Using this install plan:";
746  install_plan.Dump();
747
748  shared_ptr<InstallPlanAction> install_plan_action(
749      new InstallPlanAction(install_plan));
750  actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
751
752  BuildPostInstallActions(install_plan_action.get());
753
754  // Enqueue the actions
755  for (const shared_ptr<AbstractAction>& action : actions_) {
756    processor_->EnqueueAction(action.get());
757  }
758
759  // Update the payload state for Rollback.
760  system_state_->payload_state()->Rollback();
761
762  SetStatusAndNotify(UPDATE_STATUS_ATTEMPTING_ROLLBACK);
763
764  // Just in case we didn't update boot flags yet, make sure they're updated
765  // before any update processing starts. This also schedules the start of the
766  // actions we just posted.
767  start_action_processor_ = true;
768  UpdateBootFlags();
769  return true;
770}
771
772bool UpdateAttempter::CanRollback() const {
773  // We can only rollback if the update_engine isn't busy and we have a valid
774  // rollback partition.
775  return (status_ == UPDATE_STATUS_IDLE &&
776          GetRollbackSlot() != BootControlInterface::kInvalidSlot);
777}
778
779BootControlInterface::Slot UpdateAttempter::GetRollbackSlot() const {
780  LOG(INFO) << "UpdateAttempter::GetRollbackSlot";
781  const unsigned int num_slots = system_state_->boot_control()->GetNumSlots();
782  const BootControlInterface::Slot current_slot =
783      system_state_->boot_control()->GetCurrentSlot();
784
785  LOG(INFO) << "  Installed slots: " << num_slots;
786  LOG(INFO) << "  Booted from slot: "
787            << BootControlInterface::SlotName(current_slot);
788
789  if (current_slot == BootControlInterface::kInvalidSlot || num_slots < 2) {
790    LOG(INFO) << "Device is not updateable.";
791    return BootControlInterface::kInvalidSlot;
792  }
793
794  vector<BootControlInterface::Slot> bootable_slots;
795  for(BootControlInterface::Slot slot = 0; slot < num_slots; slot++) {
796    if (slot != current_slot &&
797        system_state_->boot_control()->IsSlotBootable(slot)) {
798      LOG(INFO) << "Found bootable slot "
799                << BootControlInterface::SlotName(slot);
800      return slot;
801    }
802  }
803  LOG(INFO) << "No other bootable slot found.";
804  return BootControlInterface::kInvalidSlot;
805}
806
807vector<std::pair<string, bool>> UpdateAttempter::GetKernelDevices() const {
808  const unsigned int num_slots = system_state_->boot_control()->GetNumSlots();
809  const BootControlInterface::Slot current_slot =
810      system_state_->boot_control()->GetCurrentSlot();
811
812  vector<std::pair<string, bool>> info_list;
813  for (BootControlInterface::Slot slot = 0; slot < num_slots; slot++) {
814    bool bootable = system_state_->boot_control()->IsSlotBootable(slot);
815    string device_name;
816    if (!system_state_->boot_control()->GetPartitionDevice(
817            kLegacyPartitionNameKernel, slot, &device_name)) {
818      continue;
819    }
820    // Add '*' to the name of the partition we booted from.
821    if (slot == current_slot)
822      device_name += '*';
823    info_list.emplace_back(device_name, bootable);
824  }
825
826  return info_list;
827}
828
829void UpdateAttempter::CheckForUpdate(const string& app_version,
830                                     const string& omaha_url,
831                                     bool interactive) {
832  LOG(INFO) << "Forced update check requested.";
833  forced_app_version_.clear();
834  forced_omaha_url_.clear();
835
836  // Certain conditions must be met to allow setting custom version and update
837  // server URLs. However, kScheduledAUTestURLRequest and kAUTestURLRequest are
838  // always allowed regardless of device state.
839  if (IsAnyUpdateSourceAllowed()) {
840    forced_app_version_ = app_version;
841    forced_omaha_url_ = omaha_url;
842  }
843  if (omaha_url == kScheduledAUTestURLRequest) {
844    forced_omaha_url_ = chromeos_update_engine::kAUTestOmahaUrl;
845    // Pretend that it's not user-initiated even though it is,
846    // so as to test scattering logic, etc. which get kicked off
847    // only in scheduled update checks.
848    interactive = false;
849  } else if (omaha_url == kAUTestURLRequest) {
850    forced_omaha_url_ = chromeos_update_engine::kAUTestOmahaUrl;
851  }
852
853  if (forced_update_pending_callback_.get()) {
854    // Make sure that a scheduling request is made prior to calling the forced
855    // update pending callback.
856    ScheduleUpdates();
857    forced_update_pending_callback_->Run(true, interactive);
858  }
859}
860
861bool UpdateAttempter::RebootIfNeeded() {
862  if (status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) {
863    LOG(INFO) << "Reboot requested, but status is "
864              << UpdateStatusToString(status_) << ", so not rebooting.";
865    return false;
866  }
867
868  if (USE_POWER_MANAGEMENT && RequestPowerManagerReboot())
869    return true;
870
871  return RebootDirectly();
872}
873
874void UpdateAttempter::WriteUpdateCompletedMarker() {
875  if (update_completed_marker_.empty())
876    return;
877
878  int64_t value = system_state_->clock()->GetBootTime().ToInternalValue();
879  string contents = StringPrintf("%" PRIi64, value);
880
881  utils::WriteFile(update_completed_marker_.c_str(),
882                   contents.c_str(),
883                   contents.length());
884}
885
886bool UpdateAttempter::RequestPowerManagerReboot() {
887  org::chromium::PowerManagerProxyInterface* power_manager_proxy =
888      system_state_->power_manager_proxy();
889  if (!power_manager_proxy) {
890    LOG(WARNING) << "No PowerManager proxy defined, skipping reboot.";
891    return false;
892  }
893  LOG(INFO) << "Calling " << power_manager::kPowerManagerInterface << "."
894            << power_manager::kRequestRestartMethod;
895  chromeos::ErrorPtr error;
896  return power_manager_proxy->RequestRestart(
897      power_manager::REQUEST_RESTART_FOR_UPDATE, &error);
898}
899
900bool UpdateAttempter::RebootDirectly() {
901  vector<string> command;
902  command.push_back("/sbin/shutdown");
903  command.push_back("-r");
904  command.push_back("now");
905  LOG(INFO) << "Running \"" << JoinString(command, ' ') << "\"";
906  int rc = 0;
907  Subprocess::SynchronousExec(command, &rc, nullptr);
908  return rc == 0;
909}
910
911void UpdateAttempter::OnUpdateScheduled(EvalStatus status,
912                                        const UpdateCheckParams& params) {
913  waiting_for_scheduled_check_ = false;
914
915  if (status == EvalStatus::kSucceeded) {
916    if (!params.updates_enabled) {
917      LOG(WARNING) << "Updates permanently disabled.";
918      // Signal disabled status, then switch right back to idle. This is
919      // necessary for ensuring that observers waiting for a signal change will
920      // actually notice one on subsequent calls. Note that we don't need to
921      // re-schedule a check in this case as updates are permanently disabled;
922      // further (forced) checks may still initiate a scheduling call.
923      SetStatusAndNotify(UPDATE_STATUS_DISABLED);
924      SetStatusAndNotify(UPDATE_STATUS_IDLE);
925      return;
926    }
927
928    LOG(INFO) << "Running "
929              << (params.is_interactive ? "interactive" : "periodic")
930              << " update.";
931
932    string app_version, omaha_url;
933    if (params.is_interactive) {
934      app_version = forced_app_version_;
935      omaha_url = forced_omaha_url_;
936    } else {
937      // Flush previously generated UMA reports before periodic updates.
938      CertificateChecker::FlushReport();
939    }
940
941    Update(app_version, omaha_url, params.target_channel,
942           params.target_version_prefix, false, params.is_interactive);
943  } else {
944    LOG(WARNING)
945        << "Update check scheduling failed (possibly timed out); retrying.";
946    ScheduleUpdates();
947  }
948
949  // This check ensures that future update checks will be or are already
950  // scheduled. The check should never fail. A check failure means that there's
951  // a bug that will most likely prevent further automatic update checks. It
952  // seems better to crash in such cases and restart the update_engine daemon
953  // into, hopefully, a known good state.
954  CHECK(IsUpdateRunningOrScheduled());
955}
956
957void UpdateAttempter::UpdateLastCheckedTime() {
958  last_checked_time_ = system_state_->clock()->GetWallclockTime().ToTimeT();
959}
960
961// Delegate methods:
962void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
963                                     ErrorCode code) {
964  LOG(INFO) << "Processing Done.";
965  actions_.clear();
966
967  // Reset cpu shares back to normal.
968  CleanupCpuSharesManagement();
969
970  if (status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
971    LOG(INFO) << "Error event sent.";
972
973    // Inform scheduler of new status;
974    SetStatusAndNotify(UPDATE_STATUS_IDLE);
975    ScheduleUpdates();
976
977    if (!fake_update_success_) {
978      return;
979    }
980    LOG(INFO) << "Booted from FW B and tried to install new firmware, "
981        "so requesting reboot from user.";
982  }
983
984  if (code == ErrorCode::kSuccess) {
985    WriteUpdateCompletedMarker();
986    prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
987    prefs_->SetString(kPrefsPreviousVersion,
988                      omaha_request_params_->app_version());
989    DeltaPerformer::ResetUpdateProgress(prefs_, false);
990
991    system_state_->payload_state()->UpdateSucceeded();
992
993    // Since we're done with scattering fully at this point, this is the
994    // safest point delete the state files, as we're sure that the status is
995    // set to reboot (which means no more updates will be applied until reboot)
996    // This deletion is required for correctness as we want the next update
997    // check to re-create a new random number for the update check count.
998    // Similarly, we also delete the wall-clock-wait period that was persisted
999    // so that we start with a new random value for the next update check
1000    // after reboot so that the same device is not favored or punished in any
1001    // way.
1002    prefs_->Delete(kPrefsUpdateCheckCount);
1003    system_state_->payload_state()->SetScatteringWaitPeriod(TimeDelta());
1004    prefs_->Delete(kPrefsUpdateFirstSeenAt);
1005
1006    SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
1007    ScheduleUpdates();
1008    LOG(INFO) << "Update successfully applied, waiting to reboot.";
1009
1010    // This pointer is null during rollback operations, and the stats
1011    // don't make much sense then anyway.
1012    if (response_handler_action_) {
1013      const InstallPlan& install_plan =
1014          response_handler_action_->install_plan();
1015
1016      // Generate an unique payload identifier.
1017      const string target_version_uid =
1018          install_plan.payload_hash + ":" + install_plan.metadata_signature;
1019
1020      // Expect to reboot into the new version to send the proper metric during
1021      // next boot.
1022      system_state_->payload_state()->ExpectRebootInNewVersion(
1023          target_version_uid);
1024
1025      // Also report the success code so that the percentiles can be
1026      // interpreted properly for the remaining error codes in UMA.
1027      utils::SendErrorCodeToUma(system_state_, code);
1028    } else {
1029      // If we just finished a rollback, then we expect to have no Omaha
1030      // response. Otherwise, it's an error.
1031      if (system_state_->payload_state()->GetRollbackVersion().empty()) {
1032        LOG(ERROR) << "Can't send metrics because expected "
1033            "response_handler_action_ missing.";
1034      }
1035    }
1036    return;
1037  }
1038
1039  if (ScheduleErrorEventAction()) {
1040    return;
1041  }
1042  LOG(INFO) << "No update.";
1043  SetStatusAndNotify(UPDATE_STATUS_IDLE);
1044  ScheduleUpdates();
1045}
1046
1047void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
1048  // Reset cpu shares back to normal.
1049  CleanupCpuSharesManagement();
1050  download_progress_ = 0.0;
1051  SetStatusAndNotify(UPDATE_STATUS_IDLE);
1052  ScheduleUpdates();
1053  actions_.clear();
1054  error_event_.reset(nullptr);
1055}
1056
1057// Called whenever an action has finished processing, either successfully
1058// or otherwise.
1059void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
1060                                      AbstractAction* action,
1061                                      ErrorCode code) {
1062  // Reset download progress regardless of whether or not the download
1063  // action succeeded. Also, get the response code from HTTP request
1064  // actions (update download as well as the initial update check
1065  // actions).
1066  const string type = action->Type();
1067  if (type == DownloadAction::StaticType()) {
1068    download_progress_ = 0.0;
1069    DownloadAction* download_action = static_cast<DownloadAction*>(action);
1070    http_response_code_ = download_action->GetHTTPResponseCode();
1071  } else if (type == OmahaRequestAction::StaticType()) {
1072    OmahaRequestAction* omaha_request_action =
1073        static_cast<OmahaRequestAction*>(action);
1074    // If the request is not an event, then it's the update-check.
1075    if (!omaha_request_action->IsEvent()) {
1076      http_response_code_ = omaha_request_action->GetHTTPResponseCode();
1077
1078      // Record the number of consecutive failed update checks.
1079      if (http_response_code_ == kHttpResponseInternalServerError ||
1080          http_response_code_ == kHttpResponseServiceUnavailable) {
1081        consecutive_failed_update_checks_++;
1082      } else {
1083        consecutive_failed_update_checks_ = 0;
1084      }
1085
1086      // Store the server-dictated poll interval, if any.
1087      server_dictated_poll_interval_ =
1088          std::max(0, omaha_request_action->GetOutputObject().poll_interval);
1089    }
1090  }
1091  if (code != ErrorCode::kSuccess) {
1092    // If the current state is at or past the download phase, count the failure
1093    // in case a switch to full update becomes necessary. Ignore network
1094    // transfer timeouts and failures.
1095    if (status_ >= UPDATE_STATUS_DOWNLOADING &&
1096        code != ErrorCode::kDownloadTransferError) {
1097      MarkDeltaUpdateFailure();
1098    }
1099    // On failure, schedule an error event to be sent to Omaha.
1100    CreatePendingErrorEvent(action, code);
1101    return;
1102  }
1103  // Find out which action completed.
1104  if (type == OmahaResponseHandlerAction::StaticType()) {
1105    // Note that the status will be updated to DOWNLOADING when some bytes get
1106    // actually downloaded from the server and the BytesReceived callback is
1107    // invoked. This avoids notifying the user that a download has started in
1108    // cases when the server and the client are unable to initiate the download.
1109    CHECK(action == response_handler_action_.get());
1110    const InstallPlan& plan = response_handler_action_->install_plan();
1111    UpdateLastCheckedTime();
1112    new_version_ = plan.version;
1113    new_payload_size_ = plan.payload_size;
1114    SetupDownload();
1115    SetupCpuSharesManagement();
1116    SetStatusAndNotify(UPDATE_STATUS_UPDATE_AVAILABLE);
1117  } else if (type == DownloadAction::StaticType()) {
1118    SetStatusAndNotify(UPDATE_STATUS_FINALIZING);
1119  }
1120}
1121
1122void UpdateAttempter::SetDownloadStatus(bool active) {
1123  download_active_ = active;
1124  LOG(INFO) << "Download status: " << (active ? "active" : "inactive");
1125}
1126
1127void UpdateAttempter::BytesReceived(uint64_t bytes_received, uint64_t total) {
1128  if (!download_active_) {
1129    LOG(ERROR) << "BytesReceived called while not downloading.";
1130    return;
1131  }
1132  double progress = static_cast<double>(bytes_received) /
1133      static_cast<double>(total);
1134  // Self throttle based on progress. Also send notifications if
1135  // progress is too slow.
1136  const double kDeltaPercent = 0.01;  // 1%
1137  if (status_ != UPDATE_STATUS_DOWNLOADING ||
1138      bytes_received == total ||
1139      progress - download_progress_ >= kDeltaPercent ||
1140      TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) {
1141    download_progress_ = progress;
1142    SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING);
1143  }
1144}
1145
1146bool UpdateAttempter::ResetStatus() {
1147  LOG(INFO) << "Attempting to reset state from "
1148            << UpdateStatusToString(status_) << " to UPDATE_STATUS_IDLE";
1149
1150  switch (status_) {
1151    case UPDATE_STATUS_IDLE:
1152      // no-op.
1153      return true;
1154
1155    case UPDATE_STATUS_UPDATED_NEED_REBOOT:  {
1156      bool ret_value = true;
1157      status_ = UPDATE_STATUS_IDLE;
1158      LOG(INFO) << "Reset Successful";
1159
1160      // Remove the reboot marker so that if the machine is rebooted
1161      // after resetting to idle state, it doesn't go back to
1162      // UPDATE_STATUS_UPDATED_NEED_REBOOT state.
1163      if (!update_completed_marker_.empty()) {
1164        if (!base::DeleteFile(base::FilePath(update_completed_marker_), false))
1165          ret_value = false;
1166      }
1167
1168      // Notify the PayloadState that the successful payload was canceled.
1169      system_state_->payload_state()->ResetUpdateStatus();
1170
1171      return ret_value;
1172    }
1173
1174    default:
1175      LOG(ERROR) << "Reset not allowed in this state.";
1176      return false;
1177  }
1178}
1179
1180bool UpdateAttempter::GetStatus(int64_t* last_checked_time,
1181                                double* progress,
1182                                string* current_operation,
1183                                string* new_version,
1184                                int64_t* new_payload_size) {
1185  *last_checked_time = last_checked_time_;
1186  *progress = download_progress_;
1187  *current_operation = UpdateStatusToString(status_);
1188  *new_version = new_version_;
1189  *new_payload_size = new_payload_size_;
1190  return true;
1191}
1192
1193void UpdateAttempter::UpdateBootFlags() {
1194  if (update_boot_flags_running_) {
1195    LOG(INFO) << "Update boot flags running, nothing to do.";
1196    return;
1197  }
1198  if (updated_boot_flags_) {
1199    LOG(INFO) << "Already updated boot flags. Skipping.";
1200    if (start_action_processor_) {
1201      ScheduleProcessingStart();
1202    }
1203    return;
1204  }
1205  // This is purely best effort. Failures should be logged by Subprocess. Run
1206  // the script asynchronously to avoid blocking the event loop regardless of
1207  // the script runtime.
1208  update_boot_flags_running_ = true;
1209  LOG(INFO) << "Updating boot flags...";
1210  vector<string> cmd{"/usr/sbin/chromeos-setgoodkernel"};
1211  if (skip_set_good_kernel_) {
1212    CompleteUpdateBootFlags(1, "Skipping the call to set");
1213  } else {
1214    if (!Subprocess::Get().Exec(cmd,
1215                                Bind(&UpdateAttempter::CompleteUpdateBootFlags,
1216                                     base::Unretained(this)))) {
1217      CompleteUpdateBootFlags(
1218          1, "Failed to launch process to mark kernel as good");
1219    }
1220  }
1221}
1222
1223void UpdateAttempter::CompleteUpdateBootFlags(int return_code,
1224                                              const string& output) {
1225  update_boot_flags_running_ = false;
1226  updated_boot_flags_ = true;
1227  if (start_action_processor_) {
1228    ScheduleProcessingStart();
1229  }
1230}
1231
1232void UpdateAttempter::BroadcastStatus() {
1233  if (!dbus_adaptor_)
1234    return;
1235  last_notify_time_ = TimeTicks::Now();
1236  dbus_adaptor_->SendStatusUpdateSignal(
1237      last_checked_time_,
1238      download_progress_,
1239      UpdateStatusToString(status_),
1240      new_version_.c_str(),
1241      new_payload_size_);
1242}
1243
1244uint32_t UpdateAttempter::GetErrorCodeFlags()  {
1245  uint32_t flags = 0;
1246
1247  if (!system_state_->hardware()->IsNormalBootMode())
1248    flags |= static_cast<uint32_t>(ErrorCode::kDevModeFlag);
1249
1250  if (response_handler_action_.get() &&
1251      response_handler_action_->install_plan().is_resume)
1252    flags |= static_cast<uint32_t>(ErrorCode::kResumedFlag);
1253
1254  if (!system_state_->hardware()->IsOfficialBuild())
1255    flags |= static_cast<uint32_t>(ErrorCode::kTestImageFlag);
1256
1257  if (omaha_request_params_->update_url() != kProductionOmahaUrl)
1258    flags |= static_cast<uint32_t>(ErrorCode::kTestOmahaUrlFlag);
1259
1260  return flags;
1261}
1262
1263bool UpdateAttempter::ShouldCancel(ErrorCode* cancel_reason) {
1264  // Check if the channel we're attempting to update to is the same as the
1265  // target channel currently chosen by the user.
1266  OmahaRequestParams* params = system_state_->request_params();
1267  if (params->download_channel() != params->target_channel()) {
1268    LOG(ERROR) << "Aborting download as target channel: "
1269               << params->target_channel()
1270               << " is different from the download channel: "
1271               << params->download_channel();
1272    *cancel_reason = ErrorCode::kUpdateCanceledByChannelChange;
1273    return true;
1274  }
1275
1276  return false;
1277}
1278
1279void UpdateAttempter::SetStatusAndNotify(UpdateStatus status) {
1280  status_ = status;
1281  BroadcastStatus();
1282}
1283
1284void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
1285                                              ErrorCode code) {
1286  if (error_event_.get()) {
1287    // This shouldn't really happen.
1288    LOG(WARNING) << "There's already an existing pending error event.";
1289    return;
1290  }
1291
1292  // For now assume that a generic Omaha response action failure means that
1293  // there's no update so don't send an event. Also, double check that the
1294  // failure has not occurred while sending an error event -- in which case
1295  // don't schedule another. This shouldn't really happen but just in case...
1296  if ((action->Type() == OmahaResponseHandlerAction::StaticType() &&
1297       code == ErrorCode::kError) ||
1298      status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
1299    return;
1300  }
1301
1302  // Classify the code to generate the appropriate result so that
1303  // the Borgmon charts show up the results correctly.
1304  // Do this before calling GetErrorCodeForAction which could potentially
1305  // augment the bit representation of code and thus cause no matches for
1306  // the switch cases below.
1307  OmahaEvent::Result event_result;
1308  switch (code) {
1309    case ErrorCode::kOmahaUpdateIgnoredPerPolicy:
1310    case ErrorCode::kOmahaUpdateDeferredPerPolicy:
1311    case ErrorCode::kOmahaUpdateDeferredForBackoff:
1312      event_result = OmahaEvent::kResultUpdateDeferred;
1313      break;
1314    default:
1315      event_result = OmahaEvent::kResultError;
1316      break;
1317  }
1318
1319  code = GetErrorCodeForAction(action, code);
1320  fake_update_success_ = code == ErrorCode::kPostinstallBootedFromFirmwareB;
1321
1322  // Compute the final error code with all the bit flags to be sent to Omaha.
1323  code = static_cast<ErrorCode>(
1324      static_cast<uint32_t>(code) | GetErrorCodeFlags());
1325  error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
1326                                    event_result,
1327                                    code));
1328}
1329
1330bool UpdateAttempter::ScheduleErrorEventAction() {
1331  if (error_event_.get() == nullptr)
1332    return false;
1333
1334  LOG(ERROR) << "Update failed.";
1335  system_state_->payload_state()->UpdateFailed(error_event_->error_code);
1336
1337  // Send it to Uma.
1338  LOG(INFO) << "Reporting the error event";
1339  utils::SendErrorCodeToUma(system_state_, error_event_->error_code);
1340
1341  // Send it to Omaha.
1342  shared_ptr<OmahaRequestAction> error_event_action(
1343      new OmahaRequestAction(system_state_,
1344                             error_event_.release(),  // Pass ownership.
1345                             new LibcurlHttpFetcher(GetProxyResolver(),
1346                                                    system_state_),
1347                             false));
1348  actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
1349  processor_->EnqueueAction(error_event_action.get());
1350  SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT);
1351  processor_->StartProcessing();
1352  return true;
1353}
1354
1355void UpdateAttempter::SetCpuShares(utils::CpuShares shares) {
1356  if (shares_ == shares) {
1357    return;
1358  }
1359  if (utils::SetCpuShares(shares)) {
1360    shares_ = shares;
1361    LOG(INFO) << "CPU shares = " << shares_;
1362  }
1363}
1364
1365void UpdateAttempter::SetupCpuSharesManagement() {
1366  if (manage_shares_id_ != MessageLoop::kTaskIdNull) {
1367    LOG(ERROR) << "Cpu shares timeout source hasn't been destroyed.";
1368    CleanupCpuSharesManagement();
1369  }
1370  const int kCpuSharesTimeout = 2 * 60 * 60;  // 2 hours
1371  manage_shares_id_ = MessageLoop::current()->PostDelayedTask(
1372      FROM_HERE,
1373      Bind(&UpdateAttempter::ManageCpuSharesCallback, base::Unretained(this)),
1374      TimeDelta::FromSeconds(kCpuSharesTimeout));
1375  SetCpuShares(utils::kCpuSharesLow);
1376}
1377
1378void UpdateAttempter::CleanupCpuSharesManagement() {
1379  if (manage_shares_id_ != MessageLoop::kTaskIdNull) {
1380    // The UpdateAttempter is instantiated by default by the FakeSystemState,
1381    // even when it is not used. We check the manage_shares_id_ before calling
1382    // the MessageLoop::current() since the unit test using a FakeSystemState
1383    // may have not define a MessageLoop for the current thread.
1384    MessageLoop::current()->CancelTask(manage_shares_id_);
1385    manage_shares_id_ = MessageLoop::kTaskIdNull;
1386  }
1387  SetCpuShares(utils::kCpuSharesNormal);
1388}
1389
1390void UpdateAttempter::ScheduleProcessingStart() {
1391  LOG(INFO) << "Scheduling an action processor start.";
1392  start_action_processor_ = false;
1393  MessageLoop::current()->PostTask(
1394      FROM_HERE,
1395      Bind([this] { this->processor_->StartProcessing(); }));
1396}
1397
1398void UpdateAttempter::ManageCpuSharesCallback() {
1399  SetCpuShares(utils::kCpuSharesNormal);
1400  manage_shares_id_ = MessageLoop::kTaskIdNull;
1401}
1402
1403void UpdateAttempter::DisableDeltaUpdateIfNeeded() {
1404  int64_t delta_failures;
1405  if (omaha_request_params_->delta_okay() &&
1406      prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) &&
1407      delta_failures >= kMaxDeltaUpdateFailures) {
1408    LOG(WARNING) << "Too many delta update failures, forcing full update.";
1409    omaha_request_params_->set_delta_okay(false);
1410  }
1411}
1412
1413void UpdateAttempter::MarkDeltaUpdateFailure() {
1414  // Don't try to resume a failed delta update.
1415  DeltaPerformer::ResetUpdateProgress(prefs_, false);
1416  int64_t delta_failures;
1417  if (!prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) ||
1418      delta_failures < 0) {
1419    delta_failures = 0;
1420  }
1421  prefs_->SetInt64(kPrefsDeltaUpdateFailures, ++delta_failures);
1422}
1423
1424void UpdateAttempter::SetupDownload() {
1425  MultiRangeHttpFetcher* fetcher =
1426      static_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher());
1427  fetcher->ClearRanges();
1428  if (response_handler_action_->install_plan().is_resume) {
1429    // Resuming an update so fetch the update manifest metadata first.
1430    int64_t manifest_metadata_size = 0;
1431    prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size);
1432    fetcher->AddRange(0, manifest_metadata_size);
1433    // If there're remaining unprocessed data blobs, fetch them. Be careful not
1434    // to request data beyond the end of the payload to avoid 416 HTTP response
1435    // error codes.
1436    int64_t next_data_offset = 0;
1437    prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
1438    uint64_t resume_offset = manifest_metadata_size + next_data_offset;
1439    if (resume_offset < response_handler_action_->install_plan().payload_size) {
1440      fetcher->AddRange(resume_offset);
1441    }
1442  } else {
1443    fetcher->AddRange(0);
1444  }
1445}
1446
1447void UpdateAttempter::PingOmaha() {
1448  if (!processor_->IsRunning()) {
1449    shared_ptr<OmahaRequestAction> ping_action(
1450        new OmahaRequestAction(system_state_,
1451                               nullptr,
1452                               new LibcurlHttpFetcher(GetProxyResolver(),
1453                                                      system_state_),
1454                               true));
1455    actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
1456    processor_->set_delegate(nullptr);
1457    processor_->EnqueueAction(ping_action.get());
1458    // Call StartProcessing() synchronously here to avoid any race conditions
1459    // caused by multiple outstanding ping Omaha requests.  If we call
1460    // StartProcessing() asynchronously, the device can be suspended before we
1461    // get a chance to callback to StartProcessing().  When the device resumes
1462    // (assuming the device sleeps longer than the next update check period),
1463    // StartProcessing() is called back and at the same time, the next update
1464    // check is fired which eventually invokes StartProcessing().  A crash
1465    // can occur because StartProcessing() checks to make sure that the
1466    // processor is idle which it isn't due to the two concurrent ping Omaha
1467    // requests.
1468    processor_->StartProcessing();
1469  } else {
1470    LOG(WARNING) << "Action processor running, Omaha ping suppressed.";
1471  }
1472
1473  // Update the last check time here; it may be re-updated when an Omaha
1474  // response is received, but this will prevent us from repeatedly scheduling
1475  // checks in the case where a response is not received.
1476  UpdateLastCheckedTime();
1477
1478  // Update the status which will schedule the next update check
1479  SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT);
1480  ScheduleUpdates();
1481}
1482
1483
1484bool UpdateAttempter::DecrementUpdateCheckCount() {
1485  int64_t update_check_count_value;
1486
1487  if (!prefs_->Exists(kPrefsUpdateCheckCount)) {
1488    // This file does not exist. This means we haven't started our update
1489    // check count down yet, so nothing more to do. This file will be created
1490    // later when we first satisfy the wall-clock-based-wait period.
1491    LOG(INFO) << "No existing update check count. That's normal.";
1492    return true;
1493  }
1494
1495  if (prefs_->GetInt64(kPrefsUpdateCheckCount, &update_check_count_value)) {
1496    // Only if we're able to read a proper integer value, then go ahead
1497    // and decrement and write back the result in the same file, if needed.
1498    LOG(INFO) << "Update check count = " << update_check_count_value;
1499
1500    if (update_check_count_value == 0) {
1501      // It could be 0, if, for some reason, the file didn't get deleted
1502      // when we set our status to waiting for reboot. so we just leave it
1503      // as is so that we can prevent another update_check wait for this client.
1504      LOG(INFO) << "Not decrementing update check count as it's already 0.";
1505      return true;
1506    }
1507
1508    if (update_check_count_value > 0)
1509      update_check_count_value--;
1510    else
1511      update_check_count_value = 0;
1512
1513    // Write out the new value of update_check_count_value.
1514    if (prefs_->SetInt64(kPrefsUpdateCheckCount, update_check_count_value)) {
1515      // We successfully wrote out te new value, so enable the
1516      // update check based wait.
1517      LOG(INFO) << "New update check count = " << update_check_count_value;
1518      return true;
1519    }
1520  }
1521
1522  LOG(INFO) << "Deleting update check count state due to read/write errors.";
1523
1524  // We cannot read/write to the file, so disable the update check based wait
1525  // so that we don't get stuck in this OS version by any chance (which could
1526  // happen if there's some bug that causes to read/write incorrectly).
1527  // Also attempt to delete the file to do our best effort to cleanup.
1528  prefs_->Delete(kPrefsUpdateCheckCount);
1529  return false;
1530}
1531
1532
1533void UpdateAttempter::UpdateEngineStarted() {
1534  // If we just booted into a new update, keep the previous OS version
1535  // in case we rebooted because of a crash of the old version, so we
1536  // can do a proper crash report with correct information.
1537  // This must be done before calling
1538  // system_state_->payload_state()->UpdateEngineStarted() since it will
1539  // delete SystemUpdated marker file.
1540  if (system_state_->system_rebooted() &&
1541      prefs_->Exists(kPrefsSystemUpdatedMarker)) {
1542    if (!prefs_->GetString(kPrefsPreviousVersion, &prev_version_)) {
1543      // If we fail to get the version string, make sure it stays empty.
1544      prev_version_.clear();
1545    }
1546  }
1547
1548  system_state_->payload_state()->UpdateEngineStarted();
1549  StartP2PAtStartup();
1550}
1551
1552bool UpdateAttempter::StartP2PAtStartup() {
1553  if (system_state_ == nullptr ||
1554      !system_state_->p2p_manager()->IsP2PEnabled()) {
1555    LOG(INFO) << "Not starting p2p at startup since it's not enabled.";
1556    return false;
1557  }
1558
1559  if (system_state_->p2p_manager()->CountSharedFiles() < 1) {
1560    LOG(INFO) << "Not starting p2p at startup since our application "
1561              << "is not sharing any files.";
1562    return false;
1563  }
1564
1565  return StartP2PAndPerformHousekeeping();
1566}
1567
1568bool UpdateAttempter::StartP2PAndPerformHousekeeping() {
1569  if (system_state_ == nullptr)
1570    return false;
1571
1572  if (!system_state_->p2p_manager()->IsP2PEnabled()) {
1573    LOG(INFO) << "Not starting p2p since it's not enabled.";
1574    return false;
1575  }
1576
1577  LOG(INFO) << "Ensuring that p2p is running.";
1578  if (!system_state_->p2p_manager()->EnsureP2PRunning()) {
1579    LOG(ERROR) << "Error starting p2p.";
1580    return false;
1581  }
1582
1583  LOG(INFO) << "Performing p2p housekeeping.";
1584  if (!system_state_->p2p_manager()->PerformHousekeeping()) {
1585    LOG(ERROR) << "Error performing housekeeping for p2p.";
1586    return false;
1587  }
1588
1589  LOG(INFO) << "Done performing p2p housekeeping.";
1590  return true;
1591}
1592
1593bool UpdateAttempter::GetBootTimeAtUpdate(Time *out_boot_time) {
1594  if (update_completed_marker_.empty())
1595    return false;
1596
1597  string contents;
1598  if (!utils::ReadFile(update_completed_marker_, &contents))
1599    return false;
1600
1601  char *endp;
1602  int64_t stored_value = strtoll(contents.c_str(), &endp, 10);
1603  if (*endp != '\0') {
1604    LOG(ERROR) << "Error parsing file " << update_completed_marker_ << " "
1605               << "with content '" << contents << "'";
1606    return false;
1607  }
1608
1609  *out_boot_time = Time::FromInternalValue(stored_value);
1610  return true;
1611}
1612
1613bool UpdateAttempter::IsUpdateRunningOrScheduled() {
1614  return ((status_ != UPDATE_STATUS_IDLE &&
1615           status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) ||
1616          waiting_for_scheduled_check_);
1617}
1618
1619bool UpdateAttempter::IsAnyUpdateSourceAllowed() {
1620  // We allow updates from any source if either of these are true:
1621  //  * The device is running an unofficial (dev/test) image.
1622  //  * The debugd dev features are accessible (i.e. in devmode with no owner).
1623  // This protects users running a base image, while still allowing a specific
1624  // window (gated by the debug dev features) where `cros flash` is usable.
1625  if (!system_state_->hardware()->IsOfficialBuild()) {
1626    LOG(INFO) << "Non-official build; allowing any update source.";
1627    return true;
1628  }
1629
1630  // Even though the debugd tools are also gated on devmode, checking here can
1631  // save us a D-Bus call so it's worth doing explicitly.
1632  if (system_state_->hardware()->IsNormalBootMode()) {
1633    LOG(INFO) << "Not in devmode; disallowing custom update sources.";
1634    return false;
1635  }
1636
1637  // Official images in devmode are allowed a custom update source iff the
1638  // debugd dev tools are enabled.
1639  if (!debugd_proxy_)
1640    return false;
1641  int32_t dev_features = debugd::DEV_FEATURES_DISABLED;
1642  chromeos::ErrorPtr error;
1643  bool success = debugd_proxy_->QueryDevFeatures(&dev_features, &error);
1644
1645  // Some boards may not include debugd so it's expected that this may fail,
1646  // in which case we default to disallowing custom update sources.
1647  if (success && !(dev_features & debugd::DEV_FEATURES_DISABLED)) {
1648    LOG(INFO) << "Debugd dev tools enabled; allowing any update source.";
1649    return true;
1650  }
1651  LOG(INFO) << "Debugd dev tools disabled; disallowing custom update sources.";
1652  return false;
1653}
1654
1655}  // namespace chromeos_update_engine
1656