1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
//
// Copyright (C) 2014 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#ifndef APMANAGER_MANAGER_H_
#define APMANAGER_MANAGER_H_
#include <map>
#include <string>
#include <vector>
#include <base/macros.h>
#include <brillo/dbus/dbus_service_watcher.h>
#include "apmanager/device_info.h"
#include "apmanager/firewall_manager.h"
#include "apmanager/service.h"
#include "apmanager/shill_manager.h"
#include "dbus_bindings/org.chromium.apmanager.Manager.h"
namespace apmanager {
class ControlInterface;
class Manager : public org::chromium::apmanager::ManagerAdaptor,
public org::chromium::apmanager::ManagerInterface {
public:
template<typename T>
using DBusMethodResponse = brillo::dbus_utils::DBusMethodResponse<T>;
explicit Manager(ControlInterface* control_interface);
virtual ~Manager();
// Implementation of ManagerInterface.
// Handles calls to org.chromium.apmanager.Manager.CreateService().
// This is an asynchronous call, response is invoked when Service and Config
// dbus objects complete the DBus service registration.
virtual void CreateService(
std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
dbus::Message* message);
// Handles calls to org.chromium.apmanager.Manager.RemoveService().
virtual bool RemoveService(brillo::ErrorPtr* error,
dbus::Message* message,
const dbus::ObjectPath& in_service);
// Register DBus object.
void RegisterAsync(
brillo::dbus_utils::ExportedObjectManager* object_manager,
const scoped_refptr<dbus::Bus>& bus,
const base::Callback<void(bool)>& completion_callback);
virtual void Start();
virtual void Stop();
virtual void RegisterDevice(scoped_refptr<Device> device);
// Return an unuse device with AP interface mode support.
virtual scoped_refptr<Device> GetAvailableDevice();
// Return the device that's associated with the given interface
// |interface_name|.
virtual scoped_refptr<Device> GetDeviceFromInterfaceName(
const std::string& interface_name);
// Claim the given interface |interface_name| from shill.
virtual void ClaimInterface(const std::string& interface_name);
// Release the given interface |interface_name| to shill.
virtual void ReleaseInterface(const std::string& interface_name);
#if defined(__BRILLO__)
// Setup an AP mode interface. Returns true and sets |interface_name|
// on success, false otherwise.
virtual bool SetupApModeInterface(std::string* interface_name);
// Setup a station mode interface. Returns true and sets |interface_name|
// on success, false otherwise.
virtual bool SetupStationModeInterface(std::string* interface_name);
#endif // __BRILLO__
// Request/release access to DHCP port for the specified interface.
virtual void RequestDHCPPortAccess(const std::string& interface);
virtual void ReleaseDHCPPortAccess(const std::string& interface);
ControlInterface* control_interface() const { return control_interface_; }
private:
friend class ManagerTest;
// A callback that will be called when the Service/Config D-Bus
// objects/interfaces are exported successfully and ready to be used.
void OnServiceRegistered(
std::unique_ptr<DBusMethodResponse<dbus::ObjectPath>> response,
std::unique_ptr<Service> service,
bool success);
// A callback that will be called when a Device D-Bus object/interface is
// exported successfully and ready to be used.
void OnDeviceRegistered(scoped_refptr<Device> device, bool success);
// This is invoked when the owner of an AP service disappeared.
void OnAPServiceOwnerDisappeared(int service_identifier);
ControlInterface* control_interface_;
int service_identifier_;
std::unique_ptr<brillo::dbus_utils::DBusObject> dbus_object_;
scoped_refptr<dbus::Bus> bus_;
std::vector<std::unique_ptr<Service>> services_;
std::vector<scoped_refptr<Device>> devices_;
// DBus service watchers for the owner of AP services.
using DBusServiceWatcher = brillo::dbus_utils::DBusServiceWatcher;
std::map<int, std::unique_ptr<DBusServiceWatcher>> service_watchers_;
DeviceInfo device_info_;
// Manager for communicating with shill (connection manager).
ShillManager shill_manager_;
// Manager for communicating with remote firewall service.
FirewallManager firewall_manager_;
DISALLOW_COPY_AND_ASSIGN(Manager);
};
} // namespace apmanager
#endif // APMANAGER_MANAGER_H_
|
