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/dbus_service.h"
18 
19 #include <string>
20 #include <vector>
21 
22 #include <update_engine/dbus-constants.h>
23 #include <update_engine/proto_bindings/update_engine.pb.h>
24 
25 #include "update_engine/dbus_connection.h"
26 #include "update_engine/update_status_utils.h"
27 
28 namespace chromeos_update_engine {
29 
30 using brillo::ErrorPtr;
31 using chromeos_update_engine::UpdateEngineService;
32 using std::string;
33 using std::vector;
34 using update_engine::UpdateEngineStatus;
35 
36 DBusUpdateEngineService::DBusUpdateEngineService(SystemState* system_state)
37     : common_(new UpdateEngineService{system_state}) {}
38 
39 // org::chromium::UpdateEngineInterfaceInterface methods implementation.
40 
41 bool DBusUpdateEngineService::AttemptUpdate(ErrorPtr* error,
42                                             const string& in_app_version,
43                                             const string& in_omaha_url) {
44   return AttemptUpdateWithFlags(
45       error, in_app_version, in_omaha_url, 0 /* no flags */);
46 }
47 
48 bool DBusUpdateEngineService::AttemptUpdateWithFlags(
49     ErrorPtr* error,
50     const string& in_app_version,
51     const string& in_omaha_url,
52     int32_t in_flags_as_int) {
53   update_engine::AttemptUpdateFlags flags =
54       static_cast<update_engine::AttemptUpdateFlags>(in_flags_as_int);
55   bool interactive = !(flags & update_engine::kAttemptUpdateFlagNonInteractive);
56   bool result;
57   return common_->AttemptUpdate(
58       error,
59       in_app_version,
60       in_omaha_url,
61       interactive ? 0 : update_engine::UpdateAttemptFlags::kFlagNonInteractive,
62       &result);
63 }
64 
65 bool DBusUpdateEngineService::AttemptInstall(ErrorPtr* error,
66                                              const string& dlc_request) {
67   // Parse the raw parameters into protobuf.
68   DlcParameters dlc_parameters;
69   if (!dlc_parameters.ParseFromString(dlc_request)) {
70     *error = brillo::Error::Create(
71         FROM_HERE, "update_engine", "INTERNAL", "parameters are invalid.");
72     return false;
73   }
74   // Extract fields from the protobuf.
75   vector<string> dlc_module_ids;
76   for (const auto& dlc_info : dlc_parameters.dlc_infos()) {
77     if (dlc_info.dlc_id().empty()) {
78       *error = brillo::Error::Create(
79           FROM_HERE, "update_engine", "INTERNAL", "parameters are invalid.");
80       return false;
81     }
82     dlc_module_ids.push_back(dlc_info.dlc_id());
83   }
84   return common_->AttemptInstall(
85       error, dlc_parameters.omaha_url(), dlc_module_ids);
86 }
87 
88 bool DBusUpdateEngineService::AttemptRollback(ErrorPtr* error,
89                                               bool in_powerwash) {
90   return common_->AttemptRollback(error, in_powerwash);
91 }
92 
93 bool DBusUpdateEngineService::CanRollback(ErrorPtr* error,
94                                           bool* out_can_rollback) {
95   return common_->CanRollback(error, out_can_rollback);
96 }
97 
98 bool DBusUpdateEngineService::ResetStatus(ErrorPtr* error) {
99   return common_->ResetStatus(error);
100 }
101 
102 bool DBusUpdateEngineService::GetStatus(ErrorPtr* error,
103                                         int64_t* out_last_checked_time,
104                                         double* out_progress,
105                                         string* out_current_operation,
106                                         string* out_new_version,
107                                         int64_t* out_new_size) {
108   UpdateEngineStatus status;
109   if (!common_->GetStatus(error, &status)) {
110     return false;
111   }
112   *out_last_checked_time = status.last_checked_time;
113   *out_progress = status.progress;
114   *out_current_operation = UpdateStatusToString(status.status);
115   *out_new_version = status.new_version;
116   *out_new_size = status.new_size_bytes;
117   return true;
118 }
119 
120 bool DBusUpdateEngineService::RebootIfNeeded(ErrorPtr* error) {
121   return common_->RebootIfNeeded(error);
122 }
123 
124 bool DBusUpdateEngineService::SetChannel(ErrorPtr* error,
125                                          const string& in_target_channel,
126                                          bool in_is_powerwash_allowed) {
127   return common_->SetChannel(error, in_target_channel, in_is_powerwash_allowed);
128 }
129 
130 bool DBusUpdateEngineService::GetChannel(ErrorPtr* error,
131                                          bool in_get_current_channel,
132                                          string* out_channel) {
133   return common_->GetChannel(error, in_get_current_channel, out_channel);
134 }
135 
136 bool DBusUpdateEngineService::GetCohortHint(ErrorPtr* error,
137                                             string* out_cohort_hint) {
138   return common_->GetCohortHint(error, out_cohort_hint);
139 }
140 
141 bool DBusUpdateEngineService::SetCohortHint(ErrorPtr* error,
142                                             const string& in_cohort_hint) {
143   return common_->SetCohortHint(error, in_cohort_hint);
144 }
145 
146 bool DBusUpdateEngineService::SetP2PUpdatePermission(ErrorPtr* error,
147                                                      bool in_enabled) {
148   return common_->SetP2PUpdatePermission(error, in_enabled);
149 }
150 
151 bool DBusUpdateEngineService::GetP2PUpdatePermission(ErrorPtr* error,
152                                                      bool* out_enabled) {
153   return common_->GetP2PUpdatePermission(error, out_enabled);
154 }
155 
156 bool DBusUpdateEngineService::SetUpdateOverCellularPermission(ErrorPtr* error,
157                                                               bool in_allowed) {
158   return common_->SetUpdateOverCellularPermission(error, in_allowed);
159 }
160 
161 bool DBusUpdateEngineService::SetUpdateOverCellularTarget(
162     brillo::ErrorPtr* error,
163     const std::string& target_version,
164     int64_t target_size) {
165   return common_->SetUpdateOverCellularTarget(
166       error, target_version, target_size);
167 }
168 
169 bool DBusUpdateEngineService::GetUpdateOverCellularPermission(
170     ErrorPtr* error, bool* out_allowed) {
171   return common_->GetUpdateOverCellularPermission(error, out_allowed);
172 }
173 
174 bool DBusUpdateEngineService::GetDurationSinceUpdate(
175     ErrorPtr* error, int64_t* out_usec_wallclock) {
176   return common_->GetDurationSinceUpdate(error, out_usec_wallclock);
177 }
178 
179 bool DBusUpdateEngineService::GetPrevVersion(ErrorPtr* error,
180                                              string* out_prev_version) {
181   return common_->GetPrevVersion(error, out_prev_version);
182 }
183 
184 bool DBusUpdateEngineService::GetRollbackPartition(
185     ErrorPtr* error, string* out_rollback_partition_name) {
186   return common_->GetRollbackPartition(error, out_rollback_partition_name);
187 }
188 
189 bool DBusUpdateEngineService::GetLastAttemptError(
190     ErrorPtr* error, int32_t* out_last_attempt_error) {
191   return common_->GetLastAttemptError(error, out_last_attempt_error);
192 }
193 
194 bool DBusUpdateEngineService::GetEolStatus(ErrorPtr* error,
195                                            int32_t* out_eol_status) {
196   return common_->GetEolStatus(error, out_eol_status);
197 }
198 
199 UpdateEngineAdaptor::UpdateEngineAdaptor(SystemState* system_state)
200     : org::chromium::UpdateEngineInterfaceAdaptor(&dbus_service_),
201       bus_(DBusConnection::Get()->GetDBus()),
202       dbus_service_(system_state),
203       dbus_object_(nullptr,
204                    bus_,
205                    dbus::ObjectPath(update_engine::kUpdateEngineServicePath)) {}
206 
207 void UpdateEngineAdaptor::RegisterAsync(
208     const base::Callback<void(bool)>& completion_callback) {
209   RegisterWithDBusObject(&dbus_object_);
210   dbus_object_.RegisterAsync(completion_callback);
211 }
212 
213 bool UpdateEngineAdaptor::RequestOwnership() {
214   return bus_->RequestOwnershipAndBlock(update_engine::kUpdateEngineServiceName,
215                                         dbus::Bus::REQUIRE_PRIMARY);
216 }
217 
218 void UpdateEngineAdaptor::SendStatusUpdate(
219     const UpdateEngineStatus& update_engine_status) {
220   SendStatusUpdateSignal(update_engine_status.last_checked_time,
221                          update_engine_status.progress,
222                          UpdateStatusToString(update_engine_status.status),
223                          update_engine_status.new_version,
224                          update_engine_status.new_size_bytes);
225 }
226 
227 }  // namespace chromeos_update_engine
228