1//
2// Copyright (C) 2014 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_manager/default_policy.h"
18
19namespace {
20
21// A fixed minimum interval between consecutive allowed update checks. This
22// needs to be long enough to prevent busywork and/or DDoS attacks on Omaha, but
23// at the same time short enough to allow the machine to update itself
24// reasonably soon.
25const int kCheckIntervalInSeconds = 15 * 60;
26
27}  // namespace
28
29namespace chromeos_update_manager {
30
31DefaultPolicy::DefaultPolicy(chromeos_update_engine::ClockInterface* clock)
32    : clock_(clock), aux_state_(new DefaultPolicyState()) {}
33
34EvalStatus DefaultPolicy::UpdateCheckAllowed(
35    EvaluationContext* ec, State* state, std::string* error,
36    UpdateCheckParams* result) const {
37  result->updates_enabled = true;
38  result->target_channel.clear();
39  result->target_version_prefix.clear();
40  result->is_interactive = false;
41
42  // Ensure that the minimum interval is set. If there's no clock, this defaults
43  // to always allowing the update.
44  if (!aux_state_->IsLastCheckAllowedTimeSet() ||
45      ec->IsMonotonicTimeGreaterThan(
46          aux_state_->last_check_allowed_time() +
47          base::TimeDelta::FromSeconds(kCheckIntervalInSeconds))) {
48    if (clock_)
49      aux_state_->set_last_check_allowed_time(clock_->GetMonotonicTime());
50    return EvalStatus::kSucceeded;
51  }
52
53  return EvalStatus::kAskMeAgainLater;
54}
55
56EvalStatus DefaultPolicy::UpdateCanStart(
57    EvaluationContext* ec,
58    State* state,
59    std::string* error,
60    UpdateDownloadParams* result,
61    const UpdateState update_state) const {
62  result->update_can_start = true;
63  result->cannot_start_reason = UpdateCannotStartReason::kUndefined;
64  result->download_url_idx = 0;
65  result->download_url_allowed = true;
66  result->download_url_num_errors = 0;
67  result->p2p_downloading_allowed = false;
68  result->p2p_sharing_allowed = false;
69  result->do_increment_failures = false;
70  result->backoff_expiry = base::Time();
71  result->scatter_wait_period = base::TimeDelta();
72  result->scatter_check_threshold = 0;
73  return EvalStatus::kSucceeded;
74}
75
76EvalStatus DefaultPolicy::UpdateDownloadAllowed(
77    EvaluationContext* ec,
78    State* state,
79    std::string* error,
80    bool* result) const {
81  *result = true;
82  return EvalStatus::kSucceeded;
83}
84
85EvalStatus DefaultPolicy::P2PEnabled(
86    EvaluationContext* ec,
87    State* state,
88    std::string* error,
89    bool* result) const {
90  *result = false;
91  return EvalStatus::kSucceeded;
92}
93
94EvalStatus DefaultPolicy::P2PEnabledChanged(
95    EvaluationContext* ec,
96    State* state,
97    std::string* error,
98    bool* result,
99    bool prev_result) const {
100  // This policy will always prohibit P2P, so this is signaling to the caller
101  // that the decision is final (because the current value is the same as the
102  // previous one) and there's no need to issue another call.
103  *result = false;
104  return EvalStatus::kSucceeded;
105}
106
107}  // namespace chromeos_update_manager
108