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