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