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