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/daemon.h" 18 19 #include <sysexits.h> 20 21 #include <base/bind.h> 22 #include <base/location.h> 23 #if USE_BINDER 24 #include <binderwrapper/binder_wrapper.h> 25 #endif // USE_BINDER 26 27 #if USE_OMAHA 28 #include "update_engine/real_system_state.h" 29 #else // !USE_OMAHA 30 #include "update_engine/daemon_state_android.h" 31 #endif // USE_OMAHA 32 33 namespace chromeos_update_engine { 34 35 int UpdateEngineDaemon::OnInit() { 36 // Register the |subprocess_| singleton with this Daemon as the signal 37 // handler. 38 subprocess_.Init(this); 39 40 int exit_code = Daemon::OnInit(); 41 if (exit_code != EX_OK) 42 return exit_code; 43 44 #if USE_BINDER 45 android::BinderWrapper::Create(); 46 binder_watcher_.Init(); 47 #endif // USE_BINDER 48 49 #if USE_OMAHA 50 // Initialize update engine global state but continue if something fails. 51 // TODO(deymo): Move the daemon_state_ initialization to a factory method 52 // avoiding the explicit re-usage of the |bus| instance, shared between 53 // D-Bus service and D-Bus client calls. 54 RealSystemState* real_system_state = new RealSystemState(); 55 daemon_state_.reset(real_system_state); 56 LOG_IF(ERROR, !real_system_state->Initialize()) 57 << "Failed to initialize system state."; 58 #else // !USE_OMAHA 59 DaemonStateAndroid* daemon_state_android = new DaemonStateAndroid(); 60 daemon_state_.reset(daemon_state_android); 61 LOG_IF(ERROR, !daemon_state_android->Initialize()) 62 << "Failed to initialize system state."; 63 #endif // USE_OMAHA 64 65 #if USE_BINDER 66 // Create the Binder Service. 67 #if USE_OMAHA 68 binder_service_ = new BinderUpdateEngineBrilloService{real_system_state}; 69 #else // !USE_OMAHA 70 binder_service_ = new BinderUpdateEngineAndroidService{ 71 daemon_state_android->service_delegate()}; 72 #endif // USE_OMAHA 73 auto binder_wrapper = android::BinderWrapper::Get(); 74 if (!binder_wrapper->RegisterService(binder_service_->ServiceName(), 75 binder_service_)) { 76 LOG(ERROR) << "Failed to register binder service."; 77 } 78 79 daemon_state_->AddObserver(binder_service_.get()); 80 #endif // USE_BINDER 81 82 #if USE_DBUS 83 // Create the DBus service. 84 dbus_adaptor_.reset(new UpdateEngineAdaptor(real_system_state)); 85 daemon_state_->AddObserver(dbus_adaptor_.get()); 86 87 dbus_adaptor_->RegisterAsync(base::Bind(&UpdateEngineDaemon::OnDBusRegistered, 88 base::Unretained(this))); 89 LOG(INFO) << "Waiting for DBus object to be registered."; 90 #else // !USE_DBUS 91 daemon_state_->StartUpdater(); 92 #endif // USE_DBUS 93 return EX_OK; 94 } 95 96 #if USE_DBUS 97 void UpdateEngineDaemon::OnDBusRegistered(bool succeeded) { 98 if (!succeeded) { 99 LOG(ERROR) << "Registering the UpdateEngineAdaptor"; 100 QuitWithExitCode(1); 101 return; 102 } 103 104 // Take ownership of the service now that everything is initialized. We need 105 // to this now and not before to avoid exposing a well known DBus service 106 // path that doesn't have the service it is supposed to implement. 107 if (!dbus_adaptor_->RequestOwnership()) { 108 LOG(ERROR) << "Unable to take ownership of the DBus service, is there " 109 << "other update_engine daemon running?"; 110 QuitWithExitCode(1); 111 return; 112 } 113 daemon_state_->StartUpdater(); 114 } 115 #endif // USE_DBUS 116 117 } // namespace chromeos_update_engine 118