update_attempter.cc revision d38b113179e6d238ad7db16629b1146222c57c85 
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  LOG(INFO) << "Setting rollback options.";
717  InstallPlan install_plan;
718  if (install_path == NULL) {
719    TEST_AND_RETURN_FALSE(utils::GetInstallDev(
720        system_state_->hardware()->BootDevice(),
721        &install_plan.install_path));
722  }
723  else {
724    install_plan.install_path = *install_path;
725  }
726
727  install_plan.kernel_install_path =
728      utils::KernelDeviceOfBootDevice(install_plan.install_path);
729
730  // Check to see if the kernel we want to rollback too is bootable.
731  LOG(INFO) << "Validating there is something to rollback too at: "
732            << install_plan.kernel_install_path;
733  bool rollback_bootable;
734  if (!system_state_->hardware()->IsKernelBootable(
735          install_plan.kernel_install_path,
736          &rollback_bootable)) {
737    LOG(ERROR) << "Unable to read GPT kernel flags.";
738    return false;
739  }
740
741  if (!rollback_bootable) {
742    LOG(ERROR) << "There is no valid OS to rollback too.";
743    return false;
744  }
745
746  install_plan.powerwash_required = powerwash;
747  if (powerwash) {
748    // Enterprise-enrolled devices have an empty owner in their device policy.
749    string owner;
750    const policy::DevicePolicy* device_policy = system_state_->device_policy();
751    if (device_policy && (!device_policy->GetOwner(&owner) || owner.empty())) {
752      LOG(ERROR) << "Enterprise device detected. "
753                 << "Cannot perform a powerwash for enterprise devices.";
754      return false;
755    }
756  }
757
758  LOG(INFO) << "Using this install plan:";
759  install_plan.Dump();
760
761  shared_ptr<InstallPlanAction> install_plan_action(
762      new InstallPlanAction(install_plan));
763  actions_.push_back(shared_ptr<AbstractAction>(install_plan_action));
764
765  BuildPostInstallActions(install_plan_action.get());
766
767  // Enqueue the actions
768  for (vector<shared_ptr<AbstractAction> >::iterator it = actions_.begin();
769       it != actions_.end(); ++it) {
770    processor_->EnqueueAction(it->get());
771  }
772
773  // Update the payload state for Rollback.
774  system_state_->payload_state()->Rollback();
775
776  SetStatusAndNotify(UPDATE_STATUS_ATTEMPTING_ROLLBACK,
777                     kUpdateNoticeUnspecified);
778
779  // Just in case we didn't update boot flags yet, make sure they're updated
780  // before any update processing starts. This also schedules the start of the
781  // actions we just posted.
782  start_action_processor_ = true;
783  UpdateBootFlags();
784  return true;
785}
786
787bool UpdateAttempter::CanRollback() const {
788  std::vector<std::string> kernel_devices =
789      system_state_->hardware()->GetKernelDevices();
790
791  std::string boot_kernel_device =
792      system_state_->hardware()->BootKernelDevice();
793
794  auto current = std::find(kernel_devices.begin(), kernel_devices.end(),
795                           boot_kernel_device);
796
797  if(current == kernel_devices.end()) {
798    LOG(ERROR) << "Unable to find the boot kernel device in the list of "
799               << "available devices";
800    return false;
801  }
802
803  for (std::string const& device_name : kernel_devices) {
804    if (device_name != *current) {
805      bool bootable = false;
806      if (system_state_->hardware()->IsKernelBootable(device_name, &bootable) &&
807          bootable) {
808        return true;
809      }
810    }
811  }
812
813  return false;
814}
815
816void UpdateAttempter::CheckForUpdate(const string& app_version,
817                                     const string& omaha_url,
818                                     bool interactive) {
819  LOG(INFO) << "New update check requested";
820
821  if (status_ != UPDATE_STATUS_IDLE) {
822    LOG(INFO) << "Skipping update check because current status is "
823              << UpdateStatusToString(status_);
824    return;
825  }
826
827  // Read GPIO signals and determine whether this is an automated test scenario.
828  // For safety, we only allow a test update to be performed once; subsequent
829  // update requests will be carried out normally.
830  bool is_test_mode = (!is_test_update_attempted_ &&
831                       system_state_->gpio_handler()->IsTestModeSignaled());
832  if (is_test_mode) {
833    LOG(WARNING) << "this is a test mode update attempt!";
834    is_test_update_attempted_ = true;
835  }
836
837  // Pass through the interactive flag, in case we want to simulate a scheduled
838  // test.
839  Update(app_version, omaha_url, true, interactive, is_test_mode);
840}
841
842bool UpdateAttempter::RebootIfNeeded() {
843  if (status_ != UPDATE_STATUS_UPDATED_NEED_REBOOT) {
844    LOG(INFO) << "Reboot requested, but status is "
845              << UpdateStatusToString(status_) << ", so not rebooting.";
846    return false;
847  }
848  TEST_AND_RETURN_FALSE(utils::Reboot());
849  return true;
850}
851
852void UpdateAttempter::WriteUpdateCompletedMarker() {
853  if (update_completed_marker_.empty())
854    return;
855
856  int64_t value = system_state_->clock()->GetBootTime().ToInternalValue();
857  string contents = StringPrintf("%" PRIi64, value);
858
859  utils::WriteFile(update_completed_marker_.c_str(),
860                   contents.c_str(),
861                   contents.length());
862}
863
864// Delegate methods:
865void UpdateAttempter::ProcessingDone(const ActionProcessor* processor,
866                                     ErrorCode code) {
867  LOG(INFO) << "Processing Done.";
868  actions_.clear();
869
870  // Reset cpu shares back to normal.
871  CleanupCpuSharesManagement();
872
873  if (status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
874    LOG(INFO) << "Error event sent.";
875
876    // Inform scheduler of new status; also specifically inform about a failed
877    // update attempt with a test address.
878    SetStatusAndNotify(UPDATE_STATUS_IDLE,
879                       (is_using_test_url_ ? kUpdateNoticeTestAddrFailed :
880                        kUpdateNoticeUnspecified));
881
882    if (!fake_update_success_) {
883      return;
884    }
885    LOG(INFO) << "Booted from FW B and tried to install new firmware, "
886        "so requesting reboot from user.";
887  }
888
889  if (code == kErrorCodeSuccess) {
890    WriteUpdateCompletedMarker();
891    prefs_->SetInt64(kPrefsDeltaUpdateFailures, 0);
892    prefs_->SetString(kPrefsPreviousVersion,
893                      omaha_request_params_->app_version());
894    DeltaPerformer::ResetUpdateProgress(prefs_, false);
895
896    system_state_->payload_state()->UpdateSucceeded();
897
898    // Since we're done with scattering fully at this point, this is the
899    // safest point delete the state files, as we're sure that the status is
900    // set to reboot (which means no more updates will be applied until reboot)
901    // This deletion is required for correctness as we want the next update
902    // check to re-create a new random number for the update check count.
903    // Similarly, we also delete the wall-clock-wait period that was persisted
904    // so that we start with a new random value for the next update check
905    // after reboot so that the same device is not favored or punished in any
906    // way.
907    prefs_->Delete(kPrefsUpdateCheckCount);
908    prefs_->Delete(kPrefsWallClockWaitPeriod);
909    prefs_->Delete(kPrefsUpdateFirstSeenAt);
910
911    SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT,
912                       kUpdateNoticeUnspecified);
913    LOG(INFO) << "Update successfully applied, waiting to reboot.";
914
915    // This pointer is NULL during rollback operations, and the stats
916    // don't make much sense then anway.
917    if (response_handler_action_) {
918      const InstallPlan& install_plan =
919          response_handler_action_->install_plan();
920
921      // Generate an unique payload identifier.
922      const string target_version_uid =
923          install_plan.payload_hash + ":" + install_plan.metadata_signature;
924
925      // Expect to reboot into the new version to send the proper metric during
926      // next boot.
927      system_state_->payload_state()->ExpectRebootInNewVersion(
928          target_version_uid);
929
930      // Also report the success code so that the percentiles can be
931      // interpreted properly for the remaining error codes in UMA.
932      utils::SendErrorCodeToUma(system_state_, code);
933    } else {
934      // If we just finished a rollback, then we expect to have no Omaha
935      // response. Otherwise, it's an error.
936      if (system_state_->payload_state()->GetRollbackVersion().empty()) {
937        LOG(ERROR) << "Can't send metrics because expected "
938            "response_handler_action_ missing.";
939      }
940    }
941    return;
942  }
943
944  if (ScheduleErrorEventAction()) {
945    return;
946  }
947  LOG(INFO) << "No update.";
948  SetStatusAndNotify(UPDATE_STATUS_IDLE, kUpdateNoticeUnspecified);
949}
950
951void UpdateAttempter::ProcessingStopped(const ActionProcessor* processor) {
952  // Reset cpu shares back to normal.
953  CleanupCpuSharesManagement();
954  download_progress_ = 0.0;
955  SetStatusAndNotify(UPDATE_STATUS_IDLE, kUpdateNoticeUnspecified);
956  actions_.clear();
957  error_event_.reset(NULL);
958}
959
960// Called whenever an action has finished processing, either successfully
961// or otherwise.
962void UpdateAttempter::ActionCompleted(ActionProcessor* processor,
963                                      AbstractAction* action,
964                                      ErrorCode code) {
965  // Reset download progress regardless of whether or not the download
966  // action succeeded. Also, get the response code from HTTP request
967  // actions (update download as well as the initial update check
968  // actions).
969  const string type = action->Type();
970  if (type == DownloadAction::StaticType()) {
971    download_progress_ = 0.0;
972    DownloadAction* download_action = dynamic_cast<DownloadAction*>(action);
973    http_response_code_ = download_action->GetHTTPResponseCode();
974  } else if (type == OmahaRequestAction::StaticType()) {
975    OmahaRequestAction* omaha_request_action =
976        dynamic_cast<OmahaRequestAction*>(action);
977    // If the request is not an event, then it's the update-check.
978    if (!omaha_request_action->IsEvent()) {
979      http_response_code_ = omaha_request_action->GetHTTPResponseCode();
980      // Forward the server-dictated poll interval to the update check
981      // scheduler, if any.
982      if (update_check_scheduler_) {
983        update_check_scheduler_->set_poll_interval(
984            omaha_request_action->GetOutputObject().poll_interval);
985      }
986    }
987  }
988  if (code != kErrorCodeSuccess) {
989    // If the current state is at or past the download phase, count the failure
990    // in case a switch to full update becomes necessary. Ignore network
991    // transfer timeouts and failures.
992    if (status_ >= UPDATE_STATUS_DOWNLOADING &&
993        code != kErrorCodeDownloadTransferError) {
994      MarkDeltaUpdateFailure();
995    }
996    // On failure, schedule an error event to be sent to Omaha.
997    CreatePendingErrorEvent(action, code);
998    return;
999  }
1000  // Find out which action completed.
1001  if (type == OmahaResponseHandlerAction::StaticType()) {
1002    // Note that the status will be updated to DOWNLOADING when some bytes get
1003    // actually downloaded from the server and the BytesReceived callback is
1004    // invoked. This avoids notifying the user that a download has started in
1005    // cases when the server and the client are unable to initiate the download.
1006    CHECK(action == response_handler_action_.get());
1007    const InstallPlan& plan = response_handler_action_->install_plan();
1008    last_checked_time_ = time(NULL);
1009    new_version_ = plan.version;
1010    new_payload_size_ = plan.payload_size;
1011    SetupDownload();
1012    SetupCpuSharesManagement();
1013    SetStatusAndNotify(UPDATE_STATUS_UPDATE_AVAILABLE,
1014                       kUpdateNoticeUnspecified);
1015  } else if (type == DownloadAction::StaticType()) {
1016    SetStatusAndNotify(UPDATE_STATUS_FINALIZING, kUpdateNoticeUnspecified);
1017  }
1018}
1019
1020// Stop updating. An attempt will be made to record status to the disk
1021// so that updates can be resumed later.
1022void UpdateAttempter::Terminate() {
1023  // TODO(adlr): implement this method.
1024  NOTIMPLEMENTED();
1025}
1026
1027// Try to resume from a previously Terminate()d update.
1028void UpdateAttempter::ResumeUpdating() {
1029  // TODO(adlr): implement this method.
1030  NOTIMPLEMENTED();
1031}
1032
1033void UpdateAttempter::SetDownloadStatus(bool active) {
1034  download_active_ = active;
1035  LOG(INFO) << "Download status: " << (active ? "active" : "inactive");
1036}
1037
1038void UpdateAttempter::BytesReceived(uint64_t bytes_received, uint64_t total) {
1039  if (!download_active_) {
1040    LOG(ERROR) << "BytesReceived called while not downloading.";
1041    return;
1042  }
1043  double progress = static_cast<double>(bytes_received) /
1044      static_cast<double>(total);
1045  // Self throttle based on progress. Also send notifications if
1046  // progress is too slow.
1047  const double kDeltaPercent = 0.01;  // 1%
1048  if (status_ != UPDATE_STATUS_DOWNLOADING ||
1049      bytes_received == total ||
1050      progress - download_progress_ >= kDeltaPercent ||
1051      TimeTicks::Now() - last_notify_time_ >= TimeDelta::FromSeconds(10)) {
1052    download_progress_ = progress;
1053    SetStatusAndNotify(UPDATE_STATUS_DOWNLOADING, kUpdateNoticeUnspecified);
1054  }
1055}
1056
1057bool UpdateAttempter::ResetStatus() {
1058  LOG(INFO) << "Attempting to reset state from "
1059            << UpdateStatusToString(status_) << " to UPDATE_STATUS_IDLE";
1060
1061  switch (status_) {
1062    case UPDATE_STATUS_IDLE:
1063      // no-op.
1064      return true;
1065
1066    case UPDATE_STATUS_UPDATED_NEED_REBOOT:  {
1067      bool ret_value = true;
1068      status_ = UPDATE_STATUS_IDLE;
1069      LOG(INFO) << "Reset Successful";
1070
1071      // Remove the reboot marker so that if the machine is rebooted
1072      // after resetting to idle state, it doesn't go back to
1073      // UPDATE_STATUS_UPDATED_NEED_REBOOT state.
1074      if (!update_completed_marker_.empty()) {
1075        const FilePath update_completed_marker_path(update_completed_marker_);
1076        if (!file_util::Delete(update_completed_marker_path, false))
1077          ret_value = false;
1078      }
1079
1080      // Notify the PayloadState that the successful payload was canceled.
1081      system_state_->payload_state()->ResetUpdateStatus();
1082
1083      return ret_value;
1084    }
1085
1086    default:
1087      LOG(ERROR) << "Reset not allowed in this state.";
1088      return false;
1089  }
1090}
1091
1092bool UpdateAttempter::GetStatus(int64_t* last_checked_time,
1093                                double* progress,
1094                                string* current_operation,
1095                                string* new_version,
1096                                int64_t* new_payload_size) {
1097  *last_checked_time = last_checked_time_;
1098  *progress = download_progress_;
1099  *current_operation = UpdateStatusToString(status_);
1100  *new_version = new_version_;
1101  *new_payload_size = new_payload_size_;
1102  return true;
1103}
1104
1105void UpdateAttempter::UpdateBootFlags() {
1106  if (update_boot_flags_running_) {
1107    LOG(INFO) << "Update boot flags running, nothing to do.";
1108    return;
1109  }
1110  if (updated_boot_flags_) {
1111    LOG(INFO) << "Already updated boot flags. Skipping.";
1112    if (start_action_processor_) {
1113      ScheduleProcessingStart();
1114    }
1115    return;
1116  }
1117  // This is purely best effort. Failures should be logged by Subprocess. Run
1118  // the script asynchronously to avoid blocking the event loop regardless of
1119  // the script runtime.
1120  update_boot_flags_running_ = true;
1121  LOG(INFO) << "Updating boot flags...";
1122  vector<string> cmd(1, "/usr/sbin/chromeos-setgoodkernel");
1123  if (!Subprocess::Get().Exec(cmd, StaticCompleteUpdateBootFlags, this)) {
1124    CompleteUpdateBootFlags(1);
1125  }
1126}
1127
1128void UpdateAttempter::CompleteUpdateBootFlags(int return_code) {
1129  update_boot_flags_running_ = false;
1130  updated_boot_flags_ = true;
1131  if (start_action_processor_) {
1132    ScheduleProcessingStart();
1133  }
1134}
1135
1136void UpdateAttempter::StaticCompleteUpdateBootFlags(
1137    int return_code,
1138    const string& output,
1139    void* p) {
1140  reinterpret_cast<UpdateAttempter*>(p)->CompleteUpdateBootFlags(return_code);
1141}
1142
1143void UpdateAttempter::BroadcastStatus() {
1144  if (!dbus_service_) {
1145    return;
1146  }
1147  last_notify_time_ = TimeTicks::Now();
1148  update_engine_service_emit_status_update(
1149      dbus_service_,
1150      last_checked_time_,
1151      download_progress_,
1152      UpdateStatusToString(status_),
1153      new_version_.c_str(),
1154      new_payload_size_);
1155}
1156
1157uint32_t UpdateAttempter::GetErrorCodeFlags()  {
1158  uint32_t flags = 0;
1159
1160  if (!system_state_->hardware()->IsNormalBootMode())
1161    flags |= kErrorCodeDevModeFlag;
1162
1163  if (response_handler_action_.get() &&
1164      response_handler_action_->install_plan().is_resume)
1165    flags |= kErrorCodeResumedFlag;
1166
1167  if (!system_state_->hardware()->IsOfficialBuild())
1168    flags |= kErrorCodeTestImageFlag;
1169
1170  if (omaha_request_params_->update_url() != kProductionOmahaUrl)
1171    flags |= kErrorCodeTestOmahaUrlFlag;
1172
1173  return flags;
1174}
1175
1176bool UpdateAttempter::ShouldCancel(ErrorCode* cancel_reason) {
1177  // Check if the channel we're attempting to update to is the same as the
1178  // target channel currently chosen by the user.
1179  OmahaRequestParams* params = system_state_->request_params();
1180  if (params->download_channel() != params->target_channel()) {
1181    LOG(ERROR) << "Aborting download as target channel: "
1182               << params->target_channel()
1183               << " is different from the download channel: "
1184               << params->download_channel();
1185    *cancel_reason = kErrorCodeUpdateCanceledByChannelChange;
1186    return true;
1187  }
1188
1189  return false;
1190}
1191
1192void UpdateAttempter::SetStatusAndNotify(UpdateStatus status,
1193                                         UpdateNotice notice) {
1194  status_ = status;
1195  if (update_check_scheduler_) {
1196    update_check_scheduler_->SetUpdateStatus(status_, notice);
1197  }
1198  BroadcastStatus();
1199}
1200
1201void UpdateAttempter::CreatePendingErrorEvent(AbstractAction* action,
1202                                              ErrorCode code) {
1203  if (error_event_.get()) {
1204    // This shouldn't really happen.
1205    LOG(WARNING) << "There's already an existing pending error event.";
1206    return;
1207  }
1208
1209  // For now assume that a generic Omaha response action failure means that
1210  // there's no update so don't send an event. Also, double check that the
1211  // failure has not occurred while sending an error event -- in which case
1212  // don't schedule another. This shouldn't really happen but just in case...
1213  if ((action->Type() == OmahaResponseHandlerAction::StaticType() &&
1214       code == kErrorCodeError) ||
1215      status_ == UPDATE_STATUS_REPORTING_ERROR_EVENT) {
1216    return;
1217  }
1218
1219  // Classify the code to generate the appropriate result so that
1220  // the Borgmon charts show up the results correctly.
1221  // Do this before calling GetErrorCodeForAction which could potentially
1222  // augment the bit representation of code and thus cause no matches for
1223  // the switch cases below.
1224  OmahaEvent::Result event_result;
1225  switch (code) {
1226    case kErrorCodeOmahaUpdateIgnoredPerPolicy:
1227    case kErrorCodeOmahaUpdateDeferredPerPolicy:
1228    case kErrorCodeOmahaUpdateDeferredForBackoff:
1229      event_result = OmahaEvent::kResultUpdateDeferred;
1230      break;
1231    default:
1232      event_result = OmahaEvent::kResultError;
1233      break;
1234  }
1235
1236  code = GetErrorCodeForAction(action, code);
1237  fake_update_success_ = code == kErrorCodePostinstallBootedFromFirmwareB;
1238
1239  // Compute the final error code with all the bit flags to be sent to Omaha.
1240  code = static_cast<ErrorCode>(code | GetErrorCodeFlags());
1241  error_event_.reset(new OmahaEvent(OmahaEvent::kTypeUpdateComplete,
1242                                    event_result,
1243                                    code));
1244}
1245
1246bool UpdateAttempter::ScheduleErrorEventAction() {
1247  if (error_event_.get() == NULL)
1248    return false;
1249
1250  LOG(ERROR) << "Update failed.";
1251  system_state_->payload_state()->UpdateFailed(error_event_->error_code);
1252
1253  // Send it to Uma.
1254  LOG(INFO) << "Reporting the error event";
1255  utils::SendErrorCodeToUma(system_state_, error_event_->error_code);
1256
1257  // Send it to Omaha.
1258  shared_ptr<OmahaRequestAction> error_event_action(
1259      new OmahaRequestAction(system_state_,
1260                             error_event_.release(),  // Pass ownership.
1261                             new LibcurlHttpFetcher(GetProxyResolver(),
1262                                                    system_state_,
1263                                                    is_test_mode_),
1264                             false));
1265  actions_.push_back(shared_ptr<AbstractAction>(error_event_action));
1266  processor_->EnqueueAction(error_event_action.get());
1267  SetStatusAndNotify(UPDATE_STATUS_REPORTING_ERROR_EVENT,
1268                     kUpdateNoticeUnspecified);
1269  processor_->StartProcessing();
1270  return true;
1271}
1272
1273void UpdateAttempter::SetCpuShares(utils::CpuShares shares) {
1274  if (shares_ == shares) {
1275    return;
1276  }
1277  if (utils::SetCpuShares(shares)) {
1278    shares_ = shares;
1279    LOG(INFO) << "CPU shares = " << shares_;
1280  }
1281}
1282
1283void UpdateAttempter::SetupCpuSharesManagement() {
1284  if (manage_shares_source_) {
1285    LOG(ERROR) << "Cpu shares timeout source hasn't been destroyed.";
1286    CleanupCpuSharesManagement();
1287  }
1288  const int kCpuSharesTimeout = 2 * 60 * 60;  // 2 hours
1289  manage_shares_source_ = g_timeout_source_new_seconds(kCpuSharesTimeout);
1290  g_source_set_callback(manage_shares_source_,
1291                        StaticManageCpuSharesCallback,
1292                        this,
1293                        NULL);
1294  g_source_attach(manage_shares_source_, NULL);
1295  SetCpuShares(utils::kCpuSharesLow);
1296}
1297
1298void UpdateAttempter::CleanupCpuSharesManagement() {
1299  if (manage_shares_source_) {
1300    g_source_destroy(manage_shares_source_);
1301    manage_shares_source_ = NULL;
1302  }
1303  SetCpuShares(utils::kCpuSharesNormal);
1304}
1305
1306gboolean UpdateAttempter::StaticManageCpuSharesCallback(gpointer data) {
1307  return reinterpret_cast<UpdateAttempter*>(data)->ManageCpuSharesCallback();
1308}
1309
1310gboolean UpdateAttempter::StaticStartProcessing(gpointer data) {
1311  reinterpret_cast<UpdateAttempter*>(data)->processor_->StartProcessing();
1312  return FALSE;  // Don't call this callback again.
1313}
1314
1315void UpdateAttempter::ScheduleProcessingStart() {
1316  LOG(INFO) << "Scheduling an action processor start.";
1317  start_action_processor_ = false;
1318  g_idle_add(&StaticStartProcessing, this);
1319}
1320
1321bool UpdateAttempter::ManageCpuSharesCallback() {
1322  SetCpuShares(utils::kCpuSharesNormal);
1323  manage_shares_source_ = NULL;
1324  return false;  // Destroy the timeout source.
1325}
1326
1327void UpdateAttempter::DisableDeltaUpdateIfNeeded() {
1328  int64_t delta_failures;
1329  if (omaha_request_params_->delta_okay() &&
1330      prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) &&
1331      delta_failures >= kMaxDeltaUpdateFailures) {
1332    LOG(WARNING) << "Too many delta update failures, forcing full update.";
1333    omaha_request_params_->set_delta_okay(false);
1334  }
1335}
1336
1337void UpdateAttempter::MarkDeltaUpdateFailure() {
1338  // Don't try to resume a failed delta update.
1339  DeltaPerformer::ResetUpdateProgress(prefs_, false);
1340  int64_t delta_failures;
1341  if (!prefs_->GetInt64(kPrefsDeltaUpdateFailures, &delta_failures) ||
1342      delta_failures < 0) {
1343    delta_failures = 0;
1344  }
1345  prefs_->SetInt64(kPrefsDeltaUpdateFailures, ++delta_failures);
1346}
1347
1348void UpdateAttempter::SetupDownload() {
1349  MultiRangeHttpFetcher* fetcher =
1350      dynamic_cast<MultiRangeHttpFetcher*>(download_action_->http_fetcher());
1351  fetcher->ClearRanges();
1352  if (response_handler_action_->install_plan().is_resume) {
1353    // Resuming an update so fetch the update manifest metadata first.
1354    int64_t manifest_metadata_size = 0;
1355    prefs_->GetInt64(kPrefsManifestMetadataSize, &manifest_metadata_size);
1356    fetcher->AddRange(0, manifest_metadata_size);
1357    // If there're remaining unprocessed data blobs, fetch them. Be careful not
1358    // to request data beyond the end of the payload to avoid 416 HTTP response
1359    // error codes.
1360    int64_t next_data_offset = 0;
1361    prefs_->GetInt64(kPrefsUpdateStateNextDataOffset, &next_data_offset);
1362    uint64_t resume_offset = manifest_metadata_size + next_data_offset;
1363    if (resume_offset < response_handler_action_->install_plan().payload_size) {
1364      fetcher->AddRange(resume_offset);
1365    }
1366  } else {
1367    fetcher->AddRange(0);
1368  }
1369}
1370
1371void UpdateAttempter::PingOmaha() {
1372  if (!processor_->IsRunning()) {
1373    shared_ptr<OmahaRequestAction> ping_action(
1374        new OmahaRequestAction(system_state_,
1375                               NULL,
1376                               new LibcurlHttpFetcher(GetProxyResolver(),
1377                                                      system_state_,
1378                                                      is_test_mode_),
1379                               true));
1380    actions_.push_back(shared_ptr<OmahaRequestAction>(ping_action));
1381    processor_->set_delegate(NULL);
1382    processor_->EnqueueAction(ping_action.get());
1383    // Call StartProcessing() synchronously here to avoid any race conditions
1384    // caused by multiple outstanding ping Omaha requests.  If we call
1385    // StartProcessing() asynchronously, the device can be suspended before we
1386    // get a chance to callback to StartProcessing().  When the device resumes
1387    // (assuming the device sleeps longer than the next update check period),
1388    // StartProcessing() is called back and at the same time, the next update
1389    // check is fired which eventually invokes StartProcessing().  A crash
1390    // can occur because StartProcessing() checks to make sure that the
1391    // processor is idle which it isn't due to the two concurrent ping Omaha
1392    // requests.
1393    processor_->StartProcessing();
1394  } else {
1395    LOG(WARNING) << "Action processor running, Omaha ping suppressed.";
1396  }
1397
1398  // Update the status which will schedule the next update check
1399  SetStatusAndNotify(UPDATE_STATUS_UPDATED_NEED_REBOOT,
1400                     kUpdateNoticeUnspecified);
1401}
1402
1403
1404bool UpdateAttempter::DecrementUpdateCheckCount() {
1405  int64 update_check_count_value;
1406
1407  if (!prefs_->Exists(kPrefsUpdateCheckCount)) {
1408    // This file does not exist. This means we haven't started our update
1409    // check count down yet, so nothing more to do. This file will be created
1410    // later when we first satisfy the wall-clock-based-wait period.
1411    LOG(INFO) << "No existing update check count. That's normal.";
1412    return true;
1413  }
1414
1415  if (prefs_->GetInt64(kPrefsUpdateCheckCount, &update_check_count_value)) {
1416    // Only if we're able to read a proper integer value, then go ahead
1417    // and decrement and write back the result in the same file, if needed.
1418    LOG(INFO) << "Update check count = " << update_check_count_value;
1419
1420    if (update_check_count_value == 0) {
1421      // It could be 0, if, for some reason, the file didn't get deleted
1422      // when we set our status to waiting for reboot. so we just leave it
1423      // as is so that we can prevent another update_check wait for this client.
1424      LOG(INFO) << "Not decrementing update check count as it's already 0.";
1425      return true;
1426    }
1427
1428    if (update_check_count_value > 0)
1429      update_check_count_value--;
1430    else
1431      update_check_count_value = 0;
1432
1433    // Write out the new value of update_check_count_value.
1434    if (prefs_->SetInt64(kPrefsUpdateCheckCount, update_check_count_value)) {
1435      // We successfully wrote out te new value, so enable the
1436      // update check based wait.
1437      LOG(INFO) << "New update check count = " << update_check_count_value;
1438      return true;
1439    }
1440  }
1441
1442  LOG(INFO) << "Deleting update check count state due to read/write errors.";
1443
1444  // We cannot read/write to the file, so disable the update check based wait
1445  // so that we don't get stuck in this OS version by any chance (which could
1446  // happen if there's some bug that causes to read/write incorrectly).
1447  // Also attempt to delete the file to do our best effort to cleanup.
1448  prefs_->Delete(kPrefsUpdateCheckCount);
1449  return false;
1450}
1451
1452
1453void UpdateAttempter::UpdateEngineStarted() {
1454  // If we just booted into a new update, keep the previous OS version
1455  // in case we rebooted because of a crash of the old version, so we
1456  // can do a proper crash report with correcy information.
1457  // This must be done before calling
1458  // system_state_->payload_state()->UpdateEngineStarted() since it will
1459  // delete SystemUpdated marker file.
1460  if (system_state_->system_rebooted() &&
1461      prefs_->Exists(kPrefsSystemUpdatedMarker)) {
1462    if (!prefs_->GetString(kPrefsPreviousVersion, &prev_version_)) {
1463      // If we fail to get the version string, make sure it stays empty.
1464      prev_version_.clear();
1465    }
1466  }
1467
1468  system_state_->payload_state()->UpdateEngineStarted();
1469  StartP2PAtStartup();
1470}
1471
1472bool UpdateAttempter::StartP2PAtStartup() {
1473  if (system_state_ == NULL ||
1474      !system_state_->p2p_manager()->IsP2PEnabled()) {
1475    LOG(INFO) << "Not starting p2p at startup since it's not enabled.";
1476    return false;
1477  }
1478
1479  if (system_state_->p2p_manager()->CountSharedFiles() < 1) {
1480    LOG(INFO) << "Not starting p2p at startup since our application "
1481              << "is not sharing any files.";
1482    return false;
1483  }
1484
1485  return StartP2PAndPerformHousekeeping();
1486}
1487
1488bool UpdateAttempter::StartP2PAndPerformHousekeeping() {
1489  if (system_state_ == NULL)
1490    return false;
1491
1492  if (!system_state_->p2p_manager()->IsP2PEnabled()) {
1493    LOG(INFO) << "Not starting p2p since it's not enabled.";
1494    return false;
1495  }
1496
1497  LOG(INFO) << "Ensuring that p2p is running.";
1498  if (!system_state_->p2p_manager()->EnsureP2PRunning()) {
1499    LOG(ERROR) << "Error starting p2p.";
1500    return false;
1501  }
1502
1503  LOG(INFO) << "Performing p2p housekeeping.";
1504  if (!system_state_->p2p_manager()->PerformHousekeeping()) {
1505    LOG(ERROR) << "Error performing housekeeping for p2p.";
1506    return false;
1507  }
1508
1509  LOG(INFO) << "Done performing p2p housekeeping.";
1510  return true;
1511}
1512
1513bool UpdateAttempter::GetBootTimeAtUpdate(base::Time *out_boot_time) {
1514  if (update_completed_marker_.empty())
1515    return false;
1516
1517  string contents;
1518  if (!utils::ReadFile(update_completed_marker_, &contents))
1519    return false;
1520
1521  char *endp;
1522  int64_t stored_value = strtoll(contents.c_str(), &endp, 10);
1523  if (*endp != '\0') {
1524    LOG(ERROR) << "Error parsing file " << update_completed_marker_ << " "
1525               << "with content '" << contents << "'";
1526    return false;
1527  }
1528
1529  *out_boot_time = Time::FromInternalValue(stored_value);
1530  return true;
1531}
1532
1533}  // namespace chromeos_update_engine
1534