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