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