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