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 "apmanager/dbus/dbus_control.h"
18
19#include "apmanager/dbus/config_dbus_adaptor.h"
20#include "apmanager/dbus/device_dbus_adaptor.h"
21#include "apmanager/dbus/manager_dbus_adaptor.h"
22#include "apmanager/dbus/service_dbus_adaptor.h"
23#include "apmanager/dbus/shill_dbus_proxy.h"
24#include "apmanager/manager.h"
25
26#if !defined(__ANDROID__)
27#include "apmanager/dbus/permission_broker_dbus_proxy.h"
28#else
29#include "apmanager/dbus/firewalld_dbus_proxy.h"
30#endif  //__ANDROID__
31
32using brillo::dbus_utils::AsyncEventSequencer;
33using brillo::dbus_utils::ExportedObjectManager;
34
35namespace apmanager {
36
37namespace {
38const char kServiceName[] = "org.chromium.apmanager";
39const char kServicePath[] = "/org/chromium/apmanager";
40}  // namespace
41
42DBusControl::DBusControl() {}
43
44DBusControl::~DBusControl() {}
45
46void DBusControl::Init() {
47  // Setup bus connection.
48  dbus::Bus::Options options;
49  options.bus_type = dbus::Bus::SYSTEM;
50  bus_ = new dbus::Bus(options);
51  CHECK(bus_->Connect());
52
53  // Create and register ObjectManager.
54  scoped_refptr<AsyncEventSequencer> sequencer(new AsyncEventSequencer());
55  object_manager_.reset(
56      new ExportedObjectManager(bus_, dbus::ObjectPath(kServicePath)));
57  object_manager_->RegisterAsync(
58      sequencer->GetHandler("ObjectManager.RegisterAsync() failed.", true));
59
60  // Create and register Manager.
61  manager_.reset(new Manager(this));
62  manager_->RegisterAsync(
63      sequencer->GetHandler("Manager.RegisterAsync() failed.", true));
64
65  // Take over the service ownership once the objects registration is completed.
66  sequencer->OnAllTasksCompletedCall({
67    base::Bind(&DBusControl::OnObjectRegistrationCompleted,
68               base::Unretained(this))
69  });
70}
71
72void DBusControl::Shutdown() {
73  manager_.reset();
74  object_manager_.reset();
75  if (bus_) {
76    bus_->ShutdownAndBlock();
77  }
78}
79
80void DBusControl::OnObjectRegistrationCompleted(bool registration_success) {
81  // Success should always be true since we've said that failures are fatal.
82  CHECK(registration_success) << "Init of one or more objects has failed.";
83  CHECK(bus_->RequestOwnershipAndBlock(kServiceName,
84                                       dbus::Bus::REQUIRE_PRIMARY))
85      << "Unable to take ownership of " << kServiceName;
86
87  // D-Bus service is ready, now we can start the Manager.
88  manager_->Start();
89}
90
91std::unique_ptr<ConfigAdaptorInterface> DBusControl::CreateConfigAdaptor(
92    Config* config, int service_identifier) {
93  return std::unique_ptr<ConfigAdaptorInterface>(
94      new ConfigDBusAdaptor(
95          bus_, object_manager_.get(), config, service_identifier));
96}
97
98std::unique_ptr<DeviceAdaptorInterface> DBusControl::CreateDeviceAdaptor(
99    Device* device) {
100  return std::unique_ptr<DeviceAdaptorInterface>(
101      new DeviceDBusAdaptor(bus_, object_manager_.get(), device));
102}
103
104std::unique_ptr<ManagerAdaptorInterface> DBusControl::CreateManagerAdaptor(
105    Manager* manager) {
106  return std::unique_ptr<ManagerAdaptorInterface>(
107      new ManagerDBusAdaptor(bus_, object_manager_.get(), manager));
108}
109
110std::unique_ptr<ServiceAdaptorInterface> DBusControl::CreateServiceAdaptor(
111    Service* service) {
112  return std::unique_ptr<ServiceAdaptorInterface>(
113      new ServiceDBusAdaptor(bus_, object_manager_.get(), service));
114}
115
116std::unique_ptr<FirewallProxyInterface> DBusControl::CreateFirewallProxy(
117    const base::Closure& service_appeared_callback,
118    const base::Closure& service_vanished_callback) {
119#if !defined(__ANDROID__)
120  return std::unique_ptr<FirewallProxyInterface>(
121      new PermissionBrokerDBusProxy(
122          bus_, service_appeared_callback, service_vanished_callback));
123#else
124  return std::unique_ptr<FirewallProxyInterface>(
125      new FirewalldDBusProxy(
126          bus_, service_appeared_callback, service_vanished_callback));
127#endif  // __ANDROID__
128}
129
130std::unique_ptr<ShillProxyInterface> DBusControl::CreateShillProxy(
131    const base::Closure& service_appeared_callback,
132    const base::Closure& service_vanished_callback) {
133  return std::unique_ptr<ShillProxyInterface>(
134      new ShillDBusProxy(
135          bus_, service_appeared_callback, service_vanished_callback));
136}
137
138}  // namespace apmanager
139