• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "shill/dbus/chromeos_dbus_control.h"
18 
19 #include <brillo/dbus/async_event_sequencer.h>
20 
21 #if defined(__ANDROID__)
22 #include <dbus/service_constants.h>
23 #else
24 #include <chromeos/dbus/service_constants.h>
25 #endif  // __ANDROID__
26 
27 #include "shill/dbus/chromeos_device_dbus_adaptor.h"
28 #include "shill/dbus/chromeos_ipconfig_dbus_adaptor.h"
29 #include "shill/dbus/chromeos_manager_dbus_adaptor.h"
30 #include "shill/dbus/chromeos_profile_dbus_adaptor.h"
31 #include "shill/dbus/chromeos_rpc_task_dbus_adaptor.h"
32 #include "shill/dbus/chromeos_service_dbus_adaptor.h"
33 #include "shill/dbus/chromeos_third_party_vpn_dbus_adaptor.h"
34 
35 #include "shill/dbus/chromeos_dhcpcd_listener.h"
36 #include "shill/dbus/chromeos_dhcpcd_proxy.h"
37 #if defined(__ANDROID__)
38 #include "shill/dbus/chromeos_firewalld_proxy.h"
39 #include "shill/power_manager_proxy_stub.h"
40 #include "shill/upstart/upstart_proxy_stub.h"
41 #else
42 #include "shill/dbus/chromeos_permission_broker_proxy.h"
43 #include "shill/dbus/chromeos_power_manager_proxy.h"
44 #include "shill/dbus/chromeos_upstart_proxy.h"
45 #endif  // __ANDROID__
46 #include "shill/dbus/chromeos_dbus_service_watcher.h"
47 
48 #if !defined(DISABLE_CELLULAR)
49 #include "shill/dbus/chromeos_dbus_objectmanager_proxy.h"
50 #include "shill/dbus/chromeos_dbus_properties_proxy.h"
51 #include "shill/dbus/chromeos_mm1_modem_modem3gpp_proxy.h"
52 #include "shill/dbus/chromeos_mm1_modem_modemcdma_proxy.h"
53 #include "shill/dbus/chromeos_mm1_modem_proxy.h"
54 #include "shill/dbus/chromeos_mm1_modem_simple_proxy.h"
55 #include "shill/dbus/chromeos_mm1_sim_proxy.h"
56 #include "shill/dbus/chromeos_modem_cdma_proxy.h"
57 #include "shill/dbus/chromeos_modem_gobi_proxy.h"
58 #include "shill/dbus/chromeos_modem_gsm_card_proxy.h"
59 #include "shill/dbus/chromeos_modem_gsm_network_proxy.h"
60 #include "shill/dbus/chromeos_modem_manager_proxy.h"
61 #include "shill/dbus/chromeos_modem_proxy.h"
62 #include "shill/dbus/chromeos_modem_simple_proxy.h"
63 #endif  // DISABLE_CELLULAR
64 
65 #if !defined(DISABLE_WIFI)
66 #include "shill/dbus/chromeos_supplicant_bss_proxy.h"
67 #endif  // DISABLE_WIFI
68 
69 #if !defined(DISABLE_WIFI) || !defined(DISABLE_WIRED_8021X)
70 #include "shill/dbus/chromeos_supplicant_interface_proxy.h"
71 #include "shill/dbus/chromeos_supplicant_network_proxy.h"
72 #include "shill/dbus/chromeos_supplicant_process_proxy.h"
73 #endif  // DISABLE_WIFI || DISABLE_WIRED_8021X
74 
75 #if !defined(DISABLE_WIMAX)
76 #include "shill/dbus/chromeos_wimax_device_proxy.h"
77 #include "shill/dbus/chromeos_wimax_manager_proxy.h"
78 #include "shill/dbus/chromeos_wimax_network_proxy.h"
79 #endif  // DISABLE_WIMAX
80 
81 #include "shill/manager.h"
82 
83 using brillo::dbus_utils::AsyncEventSequencer;
84 using std::string;
85 
86 namespace shill {
87 
88 // static.
89 const char ChromeosDBusControl::kNullPath[] = "/";
90 
ChromeosDBusControl(EventDispatcher * dispatcher)91 ChromeosDBusControl::ChromeosDBusControl(EventDispatcher* dispatcher)
92     : dispatcher_(dispatcher),
93       null_identifier_(kNullPath) {
94   dbus::Bus::Options options;
95   options.bus_type = dbus::Bus::SYSTEM;
96 
97   adaptor_bus_ = new dbus::Bus(options);
98   proxy_bus_ = new dbus::Bus(options);
99   CHECK(adaptor_bus_->Connect());
100   CHECK(proxy_bus_->Connect());
101 }
102 
~ChromeosDBusControl()103 ChromeosDBusControl::~ChromeosDBusControl() {
104   if (adaptor_bus_) {
105     adaptor_bus_->ShutdownAndBlock();
106   }
107   if (proxy_bus_) {
108     proxy_bus_->ShutdownAndBlock();
109   }
110 }
111 
NullRPCIdentifier()112 const string& ChromeosDBusControl::NullRPCIdentifier() {
113   return null_identifier_;
114 }
115 
RegisterManagerObject(Manager * manager,const base::Closure & registration_done_callback)116 void ChromeosDBusControl::RegisterManagerObject(
117     Manager* manager, const base::Closure& registration_done_callback) {
118   registration_done_callback_ = registration_done_callback;
119   scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
120   manager->RegisterAsync(
121       base::Bind(
122           &ChromeosDBusControl::OnDBusServiceRegistered,
123           base::Unretained(this),
124           sequencer->GetHandler("Manager.RegisterAsync() failed.", true)));
125   sequencer->OnAllTasksCompletedCall({
126       base::Bind(&ChromeosDBusControl::TakeServiceOwnership,
127                  base::Unretained(this))
128   });
129 }
130 
131 template <typename Object, typename AdaptorInterface, typename Adaptor>
CreateAdaptor(Object * object)132 AdaptorInterface* ChromeosDBusControl::CreateAdaptor(Object* object) {
133   return new Adaptor(adaptor_bus_, object);
134 }
135 
OnDBusServiceRegistered(const base::Callback<void (bool)> & completion_action,bool success)136 void ChromeosDBusControl::OnDBusServiceRegistered(
137     const base::Callback<void(bool)>& completion_action, bool success) {
138   // The DBus control interface will take over the ownership of the DBus service
139   // in this callback.  The daemon will crash if registration failed.
140   completion_action.Run(success);
141 
142   // We can start the manager now that we have ownership of the D-Bus service.
143   // Doing so earlier would allow the manager to emit signals before service
144   // ownership was acquired.
145   registration_done_callback_.Run();
146 }
147 
TakeServiceOwnership(bool success)148 void ChromeosDBusControl::TakeServiceOwnership(bool success) {
149   // Success should always be true since we've said that failures are fatal.
150   CHECK(success) << "Init of one or more objects has failed.";
151   CHECK(adaptor_bus_->RequestOwnershipAndBlock(kFlimflamServiceName,
152                                        dbus::Bus::REQUIRE_PRIMARY))
153       << "Unable to take ownership of " << kFlimflamServiceName;
154 }
155 
CreateDeviceAdaptor(Device * device)156 DeviceAdaptorInterface* ChromeosDBusControl::CreateDeviceAdaptor(
157     Device* device) {
158   return
159       CreateAdaptor<Device, DeviceAdaptorInterface, ChromeosDeviceDBusAdaptor>(
160           device);
161 }
162 
CreateIPConfigAdaptor(IPConfig * config)163 IPConfigAdaptorInterface* ChromeosDBusControl::CreateIPConfigAdaptor(
164     IPConfig* config) {
165   return
166       CreateAdaptor<IPConfig, IPConfigAdaptorInterface,
167                     ChromeosIPConfigDBusAdaptor>(config);
168 }
169 
CreateManagerAdaptor(Manager * manager)170 ManagerAdaptorInterface* ChromeosDBusControl::CreateManagerAdaptor(
171     Manager* manager) {
172   return new ChromeosManagerDBusAdaptor(adaptor_bus_, proxy_bus_, manager);
173 }
174 
CreateProfileAdaptor(Profile * profile)175 ProfileAdaptorInterface* ChromeosDBusControl::CreateProfileAdaptor(
176     Profile* profile) {
177   return
178       CreateAdaptor<Profile, ProfileAdaptorInterface,
179                     ChromeosProfileDBusAdaptor>(profile);
180 }
181 
CreateRPCTaskAdaptor(RPCTask * task)182 RPCTaskAdaptorInterface* ChromeosDBusControl::CreateRPCTaskAdaptor(
183     RPCTask* task) {
184   return
185       CreateAdaptor<RPCTask, RPCTaskAdaptorInterface,
186                     ChromeosRPCTaskDBusAdaptor>(task);
187 }
188 
CreateServiceAdaptor(Service * service)189 ServiceAdaptorInterface* ChromeosDBusControl::CreateServiceAdaptor(
190     Service* service) {
191   return
192       CreateAdaptor<Service, ServiceAdaptorInterface,
193                     ChromeosServiceDBusAdaptor>(service);
194 }
195 
196 #ifndef DISABLE_VPN
CreateThirdPartyVpnAdaptor(ThirdPartyVpnDriver * driver)197 ThirdPartyVpnAdaptorInterface* ChromeosDBusControl::CreateThirdPartyVpnAdaptor(
198     ThirdPartyVpnDriver* driver) {
199   return
200       CreateAdaptor<ThirdPartyVpnDriver, ThirdPartyVpnAdaptorInterface,
201                     ChromeosThirdPartyVpnDBusAdaptor>(driver);
202 }
203 #endif
204 
CreatePowerManagerProxy(PowerManagerProxyDelegate * delegate,const base::Closure & service_appeared_callback,const base::Closure & service_vanished_callback)205 PowerManagerProxyInterface* ChromeosDBusControl::CreatePowerManagerProxy(
206     PowerManagerProxyDelegate* delegate,
207     const base::Closure& service_appeared_callback,
208     const base::Closure& service_vanished_callback) {
209 #if defined(__ANDROID__)
210   return new PowerManagerProxyStub();
211 #else
212   return new ChromeosPowerManagerProxy(dispatcher_,
213                                        proxy_bus_,
214                                        delegate,
215                                        service_appeared_callback,
216                                        service_vanished_callback);
217 #endif  // __ANDROID__
218 }
219 
220 #if !defined(DISABLE_WIFI) || !defined(DISABLE_WIRED_8021X)
221 SupplicantProcessProxyInterface*
CreateSupplicantProcessProxy(const base::Closure & service_appeared_callback,const base::Closure & service_vanished_callback)222     ChromeosDBusControl::CreateSupplicantProcessProxy(
223         const base::Closure& service_appeared_callback,
224         const base::Closure& service_vanished_callback) {
225   return new ChromeosSupplicantProcessProxy(dispatcher_,
226                                             proxy_bus_,
227                                             service_appeared_callback,
228                                             service_vanished_callback);
229 }
230 
231 SupplicantInterfaceProxyInterface*
CreateSupplicantInterfaceProxy(SupplicantEventDelegateInterface * delegate,const string & object_path)232     ChromeosDBusControl::CreateSupplicantInterfaceProxy(
233         SupplicantEventDelegateInterface* delegate,
234         const string& object_path) {
235   return new ChromeosSupplicantInterfaceProxy(
236       proxy_bus_, object_path, delegate);
237 }
238 
239 SupplicantNetworkProxyInterface*
CreateSupplicantNetworkProxy(const string & object_path)240     ChromeosDBusControl::CreateSupplicantNetworkProxy(
241         const string& object_path) {
242   return new ChromeosSupplicantNetworkProxy(proxy_bus_, object_path);
243 }
244 #endif  // DISABLE_WIFI || DISABLE_WIRED_8021X
245 
246 #if !defined(DISABLE_WIFI)
CreateSupplicantBSSProxy(WiFiEndpoint * wifi_endpoint,const string & object_path)247 SupplicantBSSProxyInterface* ChromeosDBusControl::CreateSupplicantBSSProxy(
248     WiFiEndpoint* wifi_endpoint,
249     const string& object_path) {
250   return new ChromeosSupplicantBSSProxy(proxy_bus_, object_path, wifi_endpoint);
251 }
252 #endif  // DISABLE_WIFI
253 
CreateDHCPCDListener(DHCPProvider * provider)254 DHCPCDListenerInterface* ChromeosDBusControl::CreateDHCPCDListener(
255     DHCPProvider* provider) {
256   return new ChromeosDHCPCDListener(proxy_bus_, dispatcher_, provider);
257 }
258 
CreateDHCPProxy(const string & service)259 DHCPProxyInterface* ChromeosDBusControl::CreateDHCPProxy(
260     const string& service) {
261   return new ChromeosDHCPCDProxy(proxy_bus_, service);
262 }
263 
CreateUpstartProxy()264 UpstartProxyInterface* ChromeosDBusControl::CreateUpstartProxy() {
265 #if defined(__ANDROID__)
266   return new UpstartProxyStub();
267 #else
268   return new ChromeosUpstartProxy(proxy_bus_);
269 #endif  // __ANDROID__
270 }
271 
CreateFirewallProxy()272 FirewallProxyInterface* ChromeosDBusControl::CreateFirewallProxy() {
273 #if defined(__ANDROID__)
274   return new ChromeosFirewalldProxy(proxy_bus_);
275 #else
276   return new ChromeosPermissionBrokerProxy(proxy_bus_);
277 #endif  // __ANDROID__
278 }
279 
280 #if !defined(DISABLE_CELLULAR)
CreateDBusPropertiesProxy(const string & path,const string & service)281 DBusPropertiesProxyInterface* ChromeosDBusControl::CreateDBusPropertiesProxy(
282     const string& path,
283     const string& service) {
284   return new ChromeosDBusPropertiesProxy(proxy_bus_, path, service);
285 }
286 
287 DBusObjectManagerProxyInterface*
CreateDBusObjectManagerProxy(const string & path,const string & service,const base::Closure & service_appeared_callback,const base::Closure & service_vanished_callback)288     ChromeosDBusControl::CreateDBusObjectManagerProxy(
289         const string& path,
290         const string& service,
291         const base::Closure& service_appeared_callback,
292         const base::Closure& service_vanished_callback) {
293   return new ChromeosDBusObjectManagerProxy(dispatcher_,
294                                             proxy_bus_,
295                                             path,
296                                             service,
297                                             service_appeared_callback,
298                                             service_vanished_callback);
299 }
300 
301 ModemManagerProxyInterface*
CreateModemManagerProxy(ModemManagerClassic * manager,const string & path,const string & service,const base::Closure & service_appeared_callback,const base::Closure & service_vanished_callback)302     ChromeosDBusControl::CreateModemManagerProxy(
303         ModemManagerClassic* manager,
304         const string& path,
305         const string& service,
306         const base::Closure& service_appeared_callback,
307         const base::Closure& service_vanished_callback) {
308   return new ChromeosModemManagerProxy(dispatcher_,
309                                        proxy_bus_,
310                                        manager,
311                                        path,
312                                        service,
313                                        service_appeared_callback,
314                                        service_vanished_callback);
315 }
316 
CreateModemProxy(const string & path,const string & service)317 ModemProxyInterface* ChromeosDBusControl::CreateModemProxy(
318     const string& path,
319     const string& service) {
320   return new ChromeosModemProxy(proxy_bus_, path, service);
321 }
322 
CreateModemSimpleProxy(const string & path,const string & service)323 ModemSimpleProxyInterface* ChromeosDBusControl::CreateModemSimpleProxy(
324     const string& path,
325     const string& service) {
326   return new ChromeosModemSimpleProxy(proxy_bus_, path, service);
327 }
328 
CreateModemCDMAProxy(const string & path,const string & service)329 ModemCDMAProxyInterface* ChromeosDBusControl::CreateModemCDMAProxy(
330     const string& path,
331     const string& service) {
332   return new ChromeosModemCDMAProxy(proxy_bus_, path, service);
333 }
334 
CreateModemGSMCardProxy(const string & path,const string & service)335 ModemGSMCardProxyInterface* ChromeosDBusControl::CreateModemGSMCardProxy(
336     const string& path,
337     const string& service) {
338   return new ChromeosModemGSMCardProxy(proxy_bus_, path, service);
339 }
340 
CreateModemGSMNetworkProxy(const string & path,const string & service)341 ModemGSMNetworkProxyInterface* ChromeosDBusControl::CreateModemGSMNetworkProxy(
342     const string& path,
343     const string& service) {
344   return new ChromeosModemGSMNetworkProxy(proxy_bus_, path, service);
345 }
346 
CreateModemGobiProxy(const string & path,const string & service)347 ModemGobiProxyInterface* ChromeosDBusControl::CreateModemGobiProxy(
348     const string& path,
349     const string& service) {
350   return new ChromeosModemGobiProxy(proxy_bus_, path, service);
351 }
352 
353 // Proxies for ModemManager1 interfaces
354 mm1::ModemModem3gppProxyInterface*
CreateMM1ModemModem3gppProxy(const string & path,const string & service)355     ChromeosDBusControl::CreateMM1ModemModem3gppProxy(
356         const string& path,
357         const string& service) {
358   return new mm1::ChromeosModemModem3gppProxy(proxy_bus_, path, service);
359 }
360 
361 mm1::ModemModemCdmaProxyInterface*
CreateMM1ModemModemCdmaProxy(const string & path,const string & service)362     ChromeosDBusControl::CreateMM1ModemModemCdmaProxy(
363         const string& path,
364         const string& service) {
365   return new mm1::ChromeosModemModemCdmaProxy(proxy_bus_, path, service);
366 }
367 
CreateMM1ModemProxy(const string & path,const string & service)368 mm1::ModemProxyInterface* ChromeosDBusControl::CreateMM1ModemProxy(
369     const string& path,
370     const string& service) {
371   return new mm1::ChromeosModemProxy(proxy_bus_, path, service);
372 }
373 
CreateMM1ModemSimpleProxy(const string & path,const string & service)374 mm1::ModemSimpleProxyInterface* ChromeosDBusControl::CreateMM1ModemSimpleProxy(
375     const string& path,
376     const string& service) {
377   return new mm1::ChromeosModemSimpleProxy(proxy_bus_, path, service);
378 }
379 
CreateSimProxy(const string & path,const string & service)380 mm1::SimProxyInterface* ChromeosDBusControl::CreateSimProxy(
381     const string& path,
382     const string& service) {
383   return new mm1::ChromeosSimProxy(proxy_bus_, path, service);
384 }
385 #endif  // DISABLE_CELLULAR
386 
387 #if !defined(DISABLE_WIMAX)
CreateWiMaxDeviceProxy(const string & path)388 WiMaxDeviceProxyInterface* ChromeosDBusControl::CreateWiMaxDeviceProxy(
389     const string& path) {
390   return new ChromeosWiMaxDeviceProxy(proxy_bus_, path);
391 }
392 
CreateWiMaxManagerProxy(const base::Closure & service_appeared_callback,const base::Closure & service_vanished_callback)393 WiMaxManagerProxyInterface* ChromeosDBusControl::CreateWiMaxManagerProxy(
394     const base::Closure& service_appeared_callback,
395     const base::Closure& service_vanished_callback) {
396   return new ChromeosWiMaxManagerProxy(dispatcher_,
397                                        proxy_bus_,
398                                        service_appeared_callback,
399                                        service_vanished_callback);
400 }
401 
CreateWiMaxNetworkProxy(const string & path)402 WiMaxNetworkProxyInterface* ChromeosDBusControl::CreateWiMaxNetworkProxy(
403     const string& path) {
404   return new ChromeosWiMaxNetworkProxy(proxy_bus_, path);
405 }
406 #endif  // DISABLE_WIMAX
407 
408 }  // namespace shill
409