1 // 2 // Copyright (C) 2015 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/client_library/client_dbus.h" 18 19 #include <base/message_loop/message_loop.h> 20 21 #include <dbus/bus.h> 22 #include <update_engine/dbus-constants.h> 23 24 #include "update_engine/update_status_utils.h" 25 26 using chromeos_update_engine::StringToUpdateStatus; 27 using dbus::Bus; 28 using org::chromium::UpdateEngineInterfaceProxy; 29 using std::string; 30 31 namespace update_engine { 32 namespace internal { 33 34 bool DBusUpdateEngineClient::Init() { 35 Bus::Options options; 36 options.bus_type = Bus::SYSTEM; 37 scoped_refptr<Bus> bus{new Bus{options}}; 38 39 if (!bus->Connect()) 40 return false; 41 42 proxy_.reset(new UpdateEngineInterfaceProxy{bus}); 43 return true; 44 } 45 46 bool DBusUpdateEngineClient::AttemptUpdate(const string& in_app_version, 47 const string& in_omaha_url, 48 bool at_user_request) { 49 return proxy_->AttemptUpdateWithFlags( 50 in_app_version, 51 in_omaha_url, 52 (at_user_request) ? 0 : kAttemptUpdateFlagNonInteractive, 53 nullptr); 54 } 55 56 bool DBusUpdateEngineClient::GetStatus(int64_t* out_last_checked_time, 57 double* out_progress, 58 UpdateStatus* out_update_status, 59 string* out_new_version, 60 int64_t* out_new_size) const { 61 string status_as_string; 62 const bool success = proxy_->GetStatus(out_last_checked_time, 63 out_progress, 64 &status_as_string, 65 out_new_version, 66 out_new_size, 67 nullptr); 68 if (!success) { 69 return false; 70 } 71 72 return StringToUpdateStatus(status_as_string, out_update_status); 73 } 74 75 bool DBusUpdateEngineClient::SetUpdateOverCellularPermission(bool allowed) { 76 return proxy_->SetUpdateOverCellularPermission(allowed, nullptr); 77 } 78 79 bool DBusUpdateEngineClient::GetUpdateOverCellularPermission( 80 bool* allowed) const { 81 return proxy_->GetUpdateOverCellularPermission(allowed, nullptr); 82 } 83 84 bool DBusUpdateEngineClient::SetP2PUpdatePermission(bool enabled) { 85 return proxy_->SetP2PUpdatePermission(enabled, nullptr); 86 } 87 88 bool DBusUpdateEngineClient::GetP2PUpdatePermission(bool* enabled) const { 89 return proxy_->GetP2PUpdatePermission(enabled, nullptr); 90 } 91 92 bool DBusUpdateEngineClient::Rollback(bool powerwash) { 93 return proxy_->AttemptRollback(powerwash, nullptr); 94 } 95 96 bool DBusUpdateEngineClient::GetRollbackPartition( 97 string* rollback_partition) const { 98 return proxy_->GetRollbackPartition(rollback_partition, nullptr); 99 } 100 101 bool DBusUpdateEngineClient::GetPrevVersion(string* prev_version) const { 102 return proxy_->GetPrevVersion(prev_version, nullptr); 103 } 104 105 void DBusUpdateEngineClient::RebootIfNeeded() { 106 bool ret = proxy_->RebootIfNeeded(nullptr); 107 if (!ret) { 108 // Reboot error code doesn't necessarily mean that a reboot 109 // failed. For example, D-Bus may be shutdown before we receive the 110 // result. 111 LOG(INFO) << "RebootIfNeeded() failure ignored."; 112 } 113 } 114 115 bool DBusUpdateEngineClient::ResetStatus() { 116 return proxy_->ResetStatus(nullptr); 117 } 118 119 void DBusUpdateEngineClient::DBusStatusHandlersRegistered( 120 const string& interface, 121 const string& signal_name, 122 bool success) const { 123 if (!success) { 124 for (auto handler : handlers_) { 125 handler->IPCError("Could not connect to" + signal_name + 126 " on " + interface); 127 } 128 } else { 129 StatusUpdateHandlersRegistered(nullptr); 130 } 131 } 132 133 void DBusUpdateEngineClient::StatusUpdateHandlersRegistered( 134 StatusUpdateHandler* handler) const { 135 int64_t last_checked_time; 136 double progress; 137 UpdateStatus update_status; 138 string new_version; 139 int64_t new_size; 140 141 if (!GetStatus(&last_checked_time, 142 &progress, 143 &update_status, 144 &new_version, 145 &new_size)) { 146 handler->IPCError("Could not query current status"); 147 return; 148 } 149 150 std::vector<update_engine::StatusUpdateHandler*> just_handler = {handler}; 151 for (auto h : handler ? just_handler : handlers_) { 152 h->HandleStatusUpdate( 153 last_checked_time, progress, update_status, new_version, new_size); 154 } 155 } 156 157 void DBusUpdateEngineClient::RunStatusUpdateHandlers( 158 int64_t last_checked_time, 159 double progress, 160 const string& current_operation, 161 const string& new_version, 162 int64_t new_size) { 163 UpdateStatus status; 164 StringToUpdateStatus(current_operation, &status); 165 166 for (auto handler : handlers_) { 167 handler->HandleStatusUpdate( 168 last_checked_time, progress, status, new_version, new_size); 169 } 170 } 171 172 bool DBusUpdateEngineClient::UnregisterStatusUpdateHandler( 173 StatusUpdateHandler* handler) { 174 auto it = handlers_.begin(); 175 176 for (; *it != handler && it != handlers_.end(); it++); 177 178 if (it != handlers_.end()) { 179 handlers_.erase(it); 180 return true; 181 } 182 183 return false; 184 } 185 186 bool DBusUpdateEngineClient::RegisterStatusUpdateHandler( 187 StatusUpdateHandler* handler) { 188 if (!base::MessageLoopForIO::current()) { 189 LOG(FATAL) << "Cannot get UpdateEngineClient outside of message loop."; 190 return false; 191 } 192 193 handlers_.push_back(handler); 194 195 if (dbus_handler_registered_) { 196 StatusUpdateHandlersRegistered(handler); 197 return true; 198 } 199 200 proxy_->RegisterStatusUpdateSignalHandler( 201 base::Bind(&DBusUpdateEngineClient::RunStatusUpdateHandlers, 202 base::Unretained(this)), 203 base::Bind(&DBusUpdateEngineClient::DBusStatusHandlersRegistered, 204 base::Unretained(this))); 205 206 dbus_handler_registered_ = true; 207 208 return true; 209 } 210 211 bool DBusUpdateEngineClient::SetTargetChannel(const string& in_target_channel, 212 bool allow_powerwash) { 213 return proxy_->SetChannel(in_target_channel, allow_powerwash, nullptr); 214 } 215 216 bool DBusUpdateEngineClient::GetTargetChannel(string* out_channel) const { 217 return proxy_->GetChannel(false, // Get the target channel. 218 out_channel, 219 nullptr); 220 } 221 222 bool DBusUpdateEngineClient::GetChannel(string* out_channel) const { 223 return proxy_->GetChannel(true, // Get the current channel. 224 out_channel, 225 nullptr); 226 } 227 228 bool DBusUpdateEngineClient::GetLastAttemptError( 229 int32_t* last_attempt_error) const { 230 return proxy_->GetLastAttemptError(last_attempt_error, nullptr); 231 } 232 233 } // namespace internal 234 } // namespace update_engine 235
