blob: c05bc14124427b62dd2db989a056714e8b1c721f [file] [log] [blame]
mukesh agrawal8a3188d2011-12-01 20:56:44 +00001// Copyright (c) 2012 The Chromium OS Authors. All rights reserved.
Paul Stewart75897df2011-04-27 09:05:53 -07002// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
Darin Petkov002c58e2012-06-19 02:56:05 +02005#ifndef SHILL_MANAGER_H_
6#define SHILL_MANAGER_H_
Paul Stewart75897df2011-04-27 09:05:53 -07007
Darin Petkova5e07ef2012-07-09 14:27:57 +02008#include <map>
Chris Masone9be4a9d2011-05-16 15:44:09 -07009#include <string>
Paul Stewart75897df2011-04-27 09:05:53 -070010#include <vector>
Chris Masone487b8bf2011-05-13 16:27:57 -070011
Paul Stewartdfa46052012-06-26 09:44:14 -070012#include <base/cancelable_callback.h>
Paul Stewarte6132022011-08-16 09:11:02 -070013#include <base/file_path.h>
Chris Masone9be4a9d2011-05-16 15:44:09 -070014#include <base/memory/ref_counted.h>
Chris Masone487b8bf2011-05-13 16:27:57 -070015#include <base/memory/scoped_ptr.h>
Eric Shienbrood3e20a232012-02-16 11:35:56 -050016#include <base/memory/weak_ptr.h>
Chris Masone88cbd5f2011-07-03 14:30:04 -070017#include <chromeos/dbus/service_constants.h>
Paul Stewart22aa71b2011-09-16 12:15:11 -070018#include <gtest/gtest_prod.h> // for FRIEND_TEST
Paul Stewart75897df2011-04-27 09:05:53 -070019
Christopher Wiley1057cd72013-02-28 15:21:29 -080020#include "shill/crypto_util_proxy.h"
Paul Stewart75897df2011-04-27 09:05:53 -070021#include "shill/device.h"
Paul Stewart0af98bf2011-05-10 17:38:08 -070022#include "shill/device_info.h"
Paul Stewart26b327e2011-10-19 11:38:09 -070023#include "shill/event_dispatcher.h"
Gaurav Shahb790aa22012-10-23 12:51:12 -070024#include "shill/geolocation_info.h"
Gary Moraina9fb3252012-05-31 12:05:31 -070025#include "shill/hook_table.h"
Arman Ugurayab22c162012-10-08 19:08:38 -070026#include "shill/metrics.h"
Darin Petkov887f2982011-07-14 16:10:17 -070027#include "shill/modem_info.h"
Gary Morainac1bdb42012-02-16 17:42:29 -080028#include "shill/power_manager.h"
Paul Stewartf3eced92013-04-17 12:18:22 -070029#include "shill/profile.h"
Chris Masoneb925cc82011-06-22 15:39:57 -070030#include "shill/property_store.h"
Chris Masone9be4a9d2011-05-16 15:44:09 -070031#include "shill/service.h"
mukesh agrawal7a4e4002011-09-06 11:26:05 -070032#include "shill/wifi.h"
Darin Petkovb72b62e2012-05-15 16:55:36 +020033#include "shill/wimax_provider.h"
Paul Stewart75897df2011-04-27 09:05:53 -070034
35namespace shill {
36
Chris Masoned0ceb8c2011-06-02 10:05:39 -070037class ControlInterface;
Darin Petkov002c58e2012-06-19 02:56:05 +020038class DBusManager;
Paul Stewart4d5efb72012-09-17 12:24:34 -070039class DefaultProfile;
Chris Masone8fe2c7e2011-06-09 15:51:19 -070040class Error;
Paul Stewart35eff132013-04-12 12:08:40 -070041class EthernetEapProvider;
Chris Masoned0ceb8c2011-06-02 10:05:39 -070042class EventDispatcher;
Prathmesh Prabhuba99b592013-04-17 15:13:14 -070043class IPAddressStore;
Thieu Le3426c8f2012-01-11 17:35:11 -080044class ManagerAdaptorInterface;
Paul Stewart4d5efb72012-09-17 12:24:34 -070045class Resolver;
Paul Stewart85aea152013-01-22 09:31:56 -080046class StoreInterface;
Darin Petkovc3505a52013-03-18 15:13:29 +010047class VPNProvider;
Paul Stewart3c504012013-01-17 17:49:58 -080048class WiFiProvider;
Chris Masoned0ceb8c2011-06-02 10:05:39 -070049
Eric Shienbrood3e20a232012-02-16 11:35:56 -050050class Manager : public base::SupportsWeakPtr<Manager> {
Paul Stewart75897df2011-04-27 09:05:53 -070051 public:
Darin Petkova5e07ef2012-07-09 14:27:57 +020052 typedef base::Callback<void(const ServiceRefPtr &service)> ServiceCallback;
53
Chris Masone88cbd5f2011-07-03 14:30:04 -070054 struct Properties {
55 public:
Paul Stewartc681fa02012-03-02 19:40:04 -080056 Properties()
Paul Stewartd408fdf2012-05-07 17:15:57 -070057 : offline_mode(false),
58 portal_check_interval_seconds(0),
59 arp_gateway(true) {}
Chris Masone88cbd5f2011-07-03 14:30:04 -070060 bool offline_mode;
61 std::string check_portal_list;
62 std::string country;
Paul Stewartc681fa02012-03-02 19:40:04 -080063 int32 portal_check_interval_seconds;
Chris Masone88cbd5f2011-07-03 14:30:04 -070064 std::string portal_url;
Paul Stewartd32f4842012-01-11 16:08:13 -080065 std::string host_name;
Paul Stewartd408fdf2012-05-07 17:15:57 -070066 // Whether to ARP for the default gateway in the DHCP client after
67 // acquiring a lease.
68 bool arp_gateway;
Paul Stewart036dba02012-08-07 12:34:41 -070069 // Comma-separated list of technologies for which link-monitoring is
70 // enabled.
71 std::string link_monitor_technologies;
Paul Stewart4d5efb72012-09-17 12:24:34 -070072 // Comma-separated list of DNS search paths to be ignored.
73 std::string ignored_dns_search_paths;
Chris Masone88cbd5f2011-07-03 14:30:04 -070074 };
75
Chris Masone9be4a9d2011-05-16 15:44:09 -070076 Manager(ControlInterface *control_interface,
Darin Petkov887f2982011-07-14 16:10:17 -070077 EventDispatcher *dispatcher,
Thieu Le3426c8f2012-01-11 17:35:11 -080078 Metrics *metrics,
Chris Masone2ae797d2011-08-23 20:41:00 -070079 GLib *glib,
80 const std::string &run_directory,
81 const std::string &storage_directory,
82 const std::string &user_storage_format);
Chris Masone3bd3c8c2011-06-13 08:20:26 -070083 virtual ~Manager();
mukesh agrawal8f317b62011-07-15 11:53:23 -070084
85 void AddDeviceToBlackList(const std::string &device_name);
Gary Morainac1bdb42012-02-16 17:42:29 -080086
Thieu Lefb46caf2012-03-08 11:57:15 -080087 virtual void Start();
Thieu Le6c1e3bb2013-02-06 15:20:35 -080088 virtual void Stop();
Darin Petkovcb0b5662012-12-13 09:59:44 +010089 bool running() const { return running_; }
Paul Stewart75897df2011-04-27 09:05:53 -070090
Paul Stewart1b253142012-01-26 14:05:52 -080091 const ProfileRefPtr &ActiveProfile() const;
92 bool IsActiveProfile(const ProfileRefPtr &profile) const;
Chris Masone6515aab2011-10-12 16:19:09 -070093 bool MoveServiceToProfile(const ServiceRefPtr &to_move,
94 const ProfileRefPtr &destination);
Paul Stewart7f61e522012-03-22 11:13:45 -070095 ProfileRefPtr LookupProfileByRpcIdentifier(const std::string &profile_rpcid);
Chris Masone7aa5f902011-07-11 11:13:35 -070096
Paul Stewart1b1a7f22012-01-06 16:24:06 -080097 // Called via RPC call on Service (|to_set|) to set the "Profile" property.
Paul Stewartad0e5982013-07-02 08:47:47 -070098 virtual void SetProfileForService(const ServiceRefPtr &to_set,
99 const std::string &profile,
100 Error *error);
Paul Stewart1b1a7f22012-01-06 16:24:06 -0800101
Paul Stewart8c116a92012-05-02 18:30:03 -0700102 virtual void RegisterDevice(const DeviceRefPtr &to_manage);
103 virtual void DeregisterDevice(const DeviceRefPtr &to_forget);
Chris Masone9be4a9d2011-05-16 15:44:09 -0700104
mukesh agrawal4eb4d782011-12-05 17:34:37 +0000105 virtual bool HasService(const ServiceRefPtr &service);
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000106 // Register a Service with the Manager. Manager may choose to
107 // connect to it immediately.
mukesh agrawal32399322011-09-01 10:53:43 -0700108 virtual void RegisterService(const ServiceRefPtr &to_manage);
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000109 // Deregister a Service from the Manager. Caller is responsible
110 // for disconnecting the Service before-hand.
Chris Masone6515aab2011-10-12 16:19:09 -0700111 virtual void DeregisterService(const ServiceRefPtr &to_forget);
mukesh agrawal00917ce2011-11-22 23:56:55 +0000112 virtual void UpdateService(const ServiceRefPtr &to_update);
Chris Masone9be4a9d2011-05-16 15:44:09 -0700113
Darin Petkove7c6ad32012-06-29 10:22:09 +0200114 // Persists |to_update| into an appropriate profile.
115 virtual void UpdateDevice(const DeviceRefPtr &to_update);
116
Wade Guthrie60a37062013-04-02 11:39:09 -0700117 virtual void UpdateWiFiProvider();
118
Paul Stewartfdd16072011-09-16 12:41:35 -0700119 void FilterByTechnology(Technology::Identifier tech,
Paul Stewart3c504012013-01-17 17:49:58 -0800120 std::vector<DeviceRefPtr> *found) const;
Chris Masone9be4a9d2011-05-16 15:44:09 -0700121
Chris Masonee0dea762011-06-09 09:06:03 -0700122 ServiceRefPtr FindService(const std::string& name);
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800123 std::vector<std::string> EnumerateAvailableServices(Error *error);
Chris Masone9be4a9d2011-05-16 15:44:09 -0700124
Paul Stewart3c504012013-01-17 17:49:58 -0800125 // Return the complete list of services, including those that are not visible.
126 std::vector<std::string> EnumerateCompleteServices(Error *error);
127
mukesh agrawal32399322011-09-01 10:53:43 -0700128 // called via RPC (e.g., from ManagerDBusAdaptor)
Paul Stewart967eaeb2013-04-25 19:53:07 -0700129 std::map<std::string, std::string> GetLoadableProfileEntriesForService(
130 const ServiceConstRefPtr &service);
Darin Petkovb65c2452012-02-23 15:17:06 +0100131 ServiceRefPtr GetService(const KeyValueStore &args, Error *error);
Paul Stewart7f5ad572012-06-04 15:18:54 -0700132 ServiceRefPtr ConfigureService(const KeyValueStore &args, Error *error);
Paul Stewartd2e1c362013-03-03 19:06:07 -0800133 ServiceRefPtr ConfigureServiceForProfile(
134 const std::string &profile_rpcid,
135 const KeyValueStore &args,
136 Error *error);
Paul Stewart7a20aa42013-01-17 12:21:41 -0800137 ServiceRefPtr FindMatchingService(const KeyValueStore &args, Error *error);
Paul Stewart7de7e022013-08-28 09:42:50 -0700138
139 // Retrieve geolocation data from the Manager.
140 const std::map<std::string, GeolocationInfos>
141 &GetNetworksForGeolocation() const;
142
143 // Called by Device when its geolocation data has been updated.
144 virtual void OnDeviceGeolocationInfoUpdated(const DeviceRefPtr &device);
145
Paul Stewart39db5ca2013-03-18 14:15:17 -0700146 void ConnectToBestServices(Error *error);
Paul Stewart7f61e522012-03-22 11:13:45 -0700147
Paul Stewartc681fa02012-03-02 19:40:04 -0800148 // Request portal detection checks on each registered device until a portal
149 // detection attempt starts on one of them.
150 void RecheckPortal(Error *error);
Paul Stewartd215af62012-04-24 23:25:50 -0700151 // Request portal detection be restarted on the device connected to
152 // |service|.
153 virtual void RecheckPortalOnService(const ServiceRefPtr &service);
154
Wade Guthrie68d41092013-04-02 12:56:02 -0700155 virtual void RequestScan(Device::ScanType scan_type,
156 const std::string &technology, Error *error);
Paul Stewart22aa71b2011-09-16 12:15:11 -0700157 std::string GetTechnologyOrder();
158 void SetTechnologyOrder(const std::string &order, Error *error);
Gaurav Shah71354762011-11-28 19:22:49 -0800159 // Set up the profile list starting with a default profile along with
160 // an (optional) list of startup profiles.
161 void InitializeProfiles();
Paul Stewart19c871d2011-12-15 16:10:13 -0800162 // Create a profile. This does not affect the profile stack. Returns
163 // the RPC path of the created profile in |path|.
164 void CreateProfile(const std::string &name, std::string *path, Error *error);
Paul Stewart5dc40aa2011-10-28 19:43:43 -0700165 // Pushes existing profile with name |name| onto stack of managed profiles.
Paul Stewart19c871d2011-12-15 16:10:13 -0800166 // Returns the RPC path of the pushed profile in |path|.
167 void PushProfile(const std::string &name, std::string *path, Error *error);
Paul Stewartf3eced92013-04-17 12:18:22 -0700168 // Insert an existing user profile with name |name| into the stack of
169 // managed profiles. Associate |user_hash| with this profile entry.
170 // Returns the RPC path of the pushed profile in |path|.
171 void InsertUserProfile(const std::string &name,
172 const std::string &user_hash,
173 std::string *path,
174 Error *error);
Paul Stewart5dc40aa2011-10-28 19:43:43 -0700175 // Pops profile named |name| off the top of the stack of managed profiles.
176 void PopProfile(const std::string &name, Error *error);
177 // Remove the active profile.
178 void PopAnyProfile(Error *error);
Paul Stewart307c2502013-03-23 12:32:10 -0700179 // Remove all user profiles from the stack of managed profiles leaving only
180 // default profiles.
181 void PopAllUserProfiles(Error *error);
Paul Stewarte73d05c2012-03-29 16:26:05 -0700182 // Remove the underlying persistent storage for a profile.
183 void RemoveProfile(const std::string &name, Error *error);
Paul Stewartd3d03882013-08-29 15:43:42 -0700184 // Called by a service to remove its associated configuration. If |service|
185 // is associated with a non-ephemeral profile, this configuration entry
186 // will be removed and the manager will search for another matching profile.
187 // If the service ends up with no matching profile, it is unloaded (which
188 // may also remove the service from the manager's list, e.g. WiFi services
189 // that are not visible)..
190 void RemoveService(const ServiceRefPtr &service);
Paul Stewart75225512012-01-26 22:51:33 -0800191 // Handle the event where a profile is about to remove a profile entry.
192 // Any Services that are dependent on this storage identifier will need
193 // to find new profiles. Return true if any service has been moved to a new
194 // profile. Any such services will have had the profile group removed from
195 // the profile.
196 virtual bool HandleProfileEntryDeletion(const ProfileRefPtr &profile,
197 const std::string &entry_name);
Paul Stewart13ed2252012-03-21 12:52:46 -0700198 // Find a registered service that contains a GUID property that
199 // matches |guid|.
200 virtual ServiceRefPtr GetServiceWithGUID(const std::string &guid,
201 Error *error);
Paul Stewart0756db92012-01-27 08:34:47 -0800202 // Find a service that is both the member of |profile| and has a
203 // storage identifier that matches |entry_name|. This function is
204 // called by the Profile in order to return a profile entry's properties.
205 virtual ServiceRefPtr GetServiceWithStorageIdentifier(
206 const ProfileRefPtr &profile,
207 const std::string &entry_name,
208 Error *error);
Paul Stewarte2bad7c2012-03-14 08:55:33 -0700209 // Return a reference to the Service associated with the default connection.
210 // If there is no such connection, this function returns a reference to NULL.
211 virtual ServiceRefPtr GetDefaultService() const;
Paul Stewart0756db92012-01-27 08:34:47 -0800212
mukesh agrawal46c27cc2013-07-10 16:39:10 -0700213 // Set enabled state of all |technology_name| devices to |enabled_state|.
214 void SetEnabledStateForTechnology(const std::string &technology_name,
215 bool enabled_state,
216 Error *error,
217 const ResultCallback &callback);
Paul Stewart20088d82012-02-16 06:58:55 -0800218 // Return whether a technology is marked as enabled for portal detection.
219 virtual bool IsPortalDetectionEnabled(Technology::Identifier tech);
Paul Stewart10e9e4e2012-04-26 19:46:28 -0700220 // Set the start-up value for the portal detection list. This list will
221 // be used until a value set explicitly over the control API. Until
222 // then, we ignore but do not overwrite whatever value is stored in the
223 // profile.
224 void SetStartupPortalList(const std::string &portal_list);
Paul Stewart20088d82012-02-16 06:58:55 -0800225
Paul Stewartd2e1c362013-03-03 19:06:07 -0800226 // Returns true if profile |a| has been pushed on the Manager's
227 // |profiles_| stack before profile |b|.
228 bool IsProfileBefore(const ProfileRefPtr &a,
229 const ProfileRefPtr &b) const;
230
Paul Stewart10ccbb32012-04-26 15:59:30 -0700231 // Return whether a service belongs to the ephemeral profile.
232 virtual bool IsServiceEphemeral(const ServiceConstRefPtr &service) const;
233
Paul Stewart3c504012013-01-17 17:49:58 -0800234 // Return whether a Technology has any connected Services.
235 virtual bool IsTechnologyConnected(Technology::Identifier technology) const;
236
Paul Stewart036dba02012-08-07 12:34:41 -0700237 // Return whether a technology is enabled for link monitoring.
238 virtual bool IsTechnologyLinkMonitorEnabled(
239 Technology::Identifier technology) const;
240
Paul Stewart3c504012013-01-17 17:49:58 -0800241 // Called by Profile when a |storage| completes initialization.
242 void OnProfileStorageInitialized(StoreInterface *storage);
243
244 // Return a Device with technology |technology| in the enabled state.
245 DeviceRefPtr GetEnabledDeviceWithTechnology(
246 Technology::Identifier technology) const;
Paul Stewart85aea152013-01-22 09:31:56 -0800247
Darin Petkov4cbff5b2013-01-29 16:29:05 +0100248 // Returns true if at least one connection exists, and false if there's no
249 // connected service.
250 virtual bool IsOnline() const;
Paul Stewart38fd24c2012-04-25 14:06:29 -0700251 std::string CalculateState(Error *error);
252
Paul Stewart03e29f72013-09-26 00:49:48 -0700253 // Recalculate the |connected_state_| string and emit a singal if it has
254 // changed.
255 void RefreshConnectionState();
256
Paul Stewartc681fa02012-03-02 19:40:04 -0800257 virtual int GetPortalCheckInterval() const {
258 return props_.portal_check_interval_seconds;
259 }
Paul Stewart20088d82012-02-16 06:58:55 -0800260 virtual const std::string &GetPortalCheckURL() const {
261 return props_.portal_url;
262 }
mukesh agrawal32399322011-09-01 10:53:43 -0700263
Darin Petkov2b8e44e2012-06-25 15:13:26 +0200264 DBusManager *dbus_manager() const { return dbus_manager_.get(); }
Chris Masone626719f2011-08-18 16:58:48 -0700265 virtual DeviceInfo *device_info() { return &device_info_; }
Paul Stewart8c116a92012-05-02 18:30:03 -0700266 virtual ModemInfo *modem_info() { return &modem_info_; }
Darin Petkovcb0b5662012-12-13 09:59:44 +0100267 PowerManager *power_manager() const { return power_manager_.get(); }
Paul Stewart35eff132013-04-12 12:08:40 -0700268 virtual EthernetEapProvider *ethernet_eap_provider() const {
269 return ethernet_eap_provider_.get();
270 }
Darin Petkovc3505a52013-03-18 15:13:29 +0100271 VPNProvider *vpn_provider() const { return vpn_provider_.get(); }
272 WiFiProvider *wifi_provider() const { return wifi_provider_.get(); }
Ben Chan520eb172013-10-30 20:51:04 -0700273#if !defined(DISABLE_WIMAX)
Paul Stewartb87d22b2013-07-29 11:11:37 -0700274 virtual WiMaxProvider *wimax_provider() { return wimax_provider_.get(); }
Ben Chan520eb172013-10-30 20:51:04 -0700275#endif // DISABLE_WIMAX
mukesh agrawalde29fa82011-09-16 16:16:36 -0700276 PropertyStore *mutable_store() { return &store_; }
277 virtual const PropertyStore &store() const { return store_; }
Darin Petkov36a3ace2012-03-06 17:22:14 +0100278 GLib *glib() const { return glib_; }
Albert Chaulk0e1cdea2013-02-27 15:32:55 -0800279 virtual const base::FilePath &run_path() const { return run_path_; }
280 const base::FilePath &storage_path() const { return storage_path_; }
Prathmesh Prabhuba99b592013-04-17 15:13:14 -0700281 IPAddressStore * health_checker_remote_ips() const {
282 return health_checker_remote_ips_.get();
283 }
Chris Masoneb925cc82011-06-22 15:39:57 -0700284
Paul Stewartd408fdf2012-05-07 17:15:57 -0700285 bool GetArpGateway() const { return props_.arp_gateway; }
286 const std::string &GetHostName() const { return props_.host_name; }
Chris Masone877ff982011-09-21 16:18:24 -0700287
Daniel Erat0818cca2012-12-14 10:16:21 -0800288 int suspend_delay_id_for_testing() const { return suspend_delay_id_; }
289
Eric Shienbrood9a245532012-03-07 14:20:39 -0500290 virtual void UpdateEnabledTechnologies();
Ben Chan5086b972013-01-15 21:51:38 -0800291 virtual void UpdateUninitializedTechnologies();
Gary Morainac1bdb42012-02-16 17:42:29 -0800292
Gary Moraind93615e2012-04-27 11:50:03 -0700293 // Writes the service |to_update| to persistant storage. If the service's is
294 // ephemeral, it is moved to the current profile.
295 void SaveServiceToProfile(const ServiceRefPtr &to_update);
296
Gary Moraina9fb3252012-05-31 12:05:31 -0700297 // Adds a closure to be executed when ChromeOS suspends or shill terminates.
298 // |name| should be unique; otherwise, a previous closure by the same name
299 // will be replaced. |start| will be called when RunTerminationActions() is
300 // called. When an action completed, TerminationActionComplete() must be
301 // called.
302 void AddTerminationAction(const std::string &name,
303 const base::Closure &start);
304
305 // Users call this function to report the completion of an action |name|.
306 // This function should be called once for each action.
307 void TerminationActionComplete(const std::string &name);
308
309 // Removes the action associtated with |name|.
310 void RemoveTerminationAction(const std::string &name);
311
Arman Ugurayab22c162012-10-08 19:08:38 -0700312 // Runs the termination actions and notifies the metrics framework
313 // that the termination actions started running, only if any termination
314 // actions have been registered. |reason| specifies whether this method was
315 // called due to termination or suspend. If all actions complete within
Darin Petkov3ec55342012-09-28 14:04:44 +0200316 // |kTerminationActionsTimeoutMilliseconds|, |done| is called with a value of
Arman Ugurayab22c162012-10-08 19:08:38 -0700317 // Error::kSuccess. Otherwise, it is called with Error::kOperationTimeout.
318 //
319 // Returns true, if termination actions were run.
320 bool RunTerminationActionsAndNotifyMetrics(
321 const base::Callback<void(const Error &)> &done,
322 Metrics::TerminationActionReason reason);
Gary Moraina9fb3252012-05-31 12:05:31 -0700323
Darin Petkova5e07ef2012-07-09 14:27:57 +0200324 // Registers a |callback| that's invoked whenever the default service
325 // changes. Returns a unique tag that can be used to deregister the
326 // callback. A tag equal to 0 is invalid.
327 virtual int RegisterDefaultServiceCallback(const ServiceCallback &callback);
328 virtual void DeregisterDefaultServiceCallback(int tag);
329
Christopher Wiley0d9cf0c2013-02-19 19:24:57 -0800330 // Verifies that the destination described by certificate is valid, and that
331 // we're currently connected to that destination. A full description of the
332 // rules being enforced is in doc/manager-api.txt. Returns true iff all
333 // checks pass, false otherwise. On false, error is filled with a
334 // descriptive error code and message.
335 //
336 // |certificate| is a PEM encoded x509 certificate, |public_key| is a base64
337 // encoded public half of an RSA key, |nonce| is a random string, and
338 // |signed_data| is a base64 encoded string as described in
339 // doc/manager-api.txt.
340 void VerifyDestination(const std::string &certificate,
341 const std::string &public_key,
342 const std::string &nonce,
343 const std::string &signed_data,
344 const std::string &destination_udn,
Christopher Wileycdde79f2013-05-01 14:26:56 -0700345 const std::string &hotspot_ssid,
346 const std::string &hotspot_bssid,
Christopher Wiley0d9cf0c2013-02-19 19:24:57 -0800347 const ResultBoolCallback &cb,
348 Error *error);
349
350 // After verifying the destination, encrypt the string data with
351 // |public_key|, the base64 encoded public half of an RSA key pair. Returns
352 // the base64 encoded result if successful, or an empty string on failure.
353 // On failure, |error| will be filled with an appropriately descriptive
354 // message and error code.
355 void VerifyAndEncryptData(const std::string &certificate,
356 const std::string &public_key,
357 const std::string &nonce,
358 const std::string &signed_data,
359 const std::string &destination_udn,
Christopher Wileycdde79f2013-05-01 14:26:56 -0700360 const std::string &hotspot_ssid,
361 const std::string &hotspot_bssid,
Christopher Wiley0d9cf0c2013-02-19 19:24:57 -0800362 const std::string &data,
363 const ResultStringCallback &cb,
364 Error *error);
365
366 // After verifying the destination, encrypt the password for |network_path|
367 // under |public_key|. Similar to EncryptData above except that the
368 // information being encrypted is implicitly the authentication credentials
369 // of the given network.
370 void VerifyAndEncryptCredentials(const std::string &certificate,
371 const std::string &public_key,
372 const std::string &nonce,
373 const std::string &signed_data,
374 const std::string &destination_udn,
Christopher Wileycdde79f2013-05-01 14:26:56 -0700375 const std::string &hotspot_ssid,
376 const std::string &hotspot_bssid,
Christopher Wiley0d9cf0c2013-02-19 19:24:57 -0800377 const std::string &network_path,
378 const ResultStringCallback &cb,
379 Error *error);
380
Paul Stewart75897df2011-04-27 09:05:53 -0700381 private:
Arman Ugurayab22c162012-10-08 19:08:38 -0700382 friend class CellularTest;
Darin Petkovc3505a52013-03-18 15:13:29 +0100383 friend class DeviceInfoTest;
Darin Petkov6f9eaa32011-08-09 15:26:44 -0700384 friend class ManagerAdaptorInterface;
Paul Stewart22aa71b2011-09-16 12:15:11 -0700385 friend class ManagerTest;
Darin Petkovcb0b5662012-12-13 09:59:44 +0100386 friend class ServiceTest;
Darin Petkovc3505a52013-03-18 15:13:29 +0100387 friend class VPNServiceTest;
Paul Stewarte369ece2012-05-22 09:11:03 -0700388 friend class WiFiObjectTest;
Darin Petkovb501ad22012-07-03 12:50:52 +0200389 friend class WiMaxProviderTest;
Arman Ugurayab22c162012-10-08 19:08:38 -0700390
Ben Chan9f3dcf82013-09-25 18:04:58 -0700391 FRIEND_TEST(CellularCapabilityUniversalMainTest, TerminationAction);
392 FRIEND_TEST(CellularCapabilityUniversalMainTest,
393 TerminationActionRemovedByStopModem);
Arman Uguray32c76402012-11-27 14:01:13 -0800394 FRIEND_TEST(CellularTest, LinkEventWontDestroyService);
Gaurav Shah435de2c2011-11-17 19:01:07 -0800395 FRIEND_TEST(ManagerTest, AvailableTechnologies);
396 FRIEND_TEST(ManagerTest, ConnectedTechnologies);
Paul Stewart39db5ca2013-03-18 14:15:17 -0700397 FRIEND_TEST(ManagerTest, ConnectToBestServices);
Gaurav Shah435de2c2011-11-17 19:01:07 -0800398 FRIEND_TEST(ManagerTest, DefaultTechnology);
Paul Stewart1b253142012-01-26 14:05:52 -0800399 FRIEND_TEST(ManagerTest, DeviceRegistrationAndStart);
Darin Petkova5e07ef2012-07-09 14:27:57 +0200400 FRIEND_TEST(ManagerTest, DisableTechnology);
401 FRIEND_TEST(ManagerTest, EnableTechnology);
Paul Stewart1b253142012-01-26 14:05:52 -0800402 FRIEND_TEST(ManagerTest, EnumerateProfiles);
Paul Stewart65512e12012-03-26 18:01:08 -0700403 FRIEND_TEST(ManagerTest, HandleProfileEntryDeletionWithUnload);
mukesh agrawal00752532013-05-03 15:46:55 -0700404 FRIEND_TEST(ManagerTest, InitializeProfilesInformsProviders);
405 FRIEND_TEST(ManagerTest, InitializeProfilesHandlesDefaults);
Paul Stewart3c504012013-01-17 17:49:58 -0800406 FRIEND_TEST(ManagerTest, IsDefaultProfile);
Paul Stewart036dba02012-08-07 12:34:41 -0700407 FRIEND_TEST(ManagerTest, LinkMonitorEnabled);
Darin Petkova5e07ef2012-07-09 14:27:57 +0200408 FRIEND_TEST(ManagerTest, NotifyDefaultServiceChanged);
Paul Stewart65512e12012-03-26 18:01:08 -0700409 FRIEND_TEST(ManagerTest, PopProfileWithUnload);
Arman Ugurayab22c162012-10-08 19:08:38 -0700410 FRIEND_TEST(ManagerTest, RunTerminationActions);
Paul Stewart1b253142012-01-26 14:05:52 -0800411 FRIEND_TEST(ManagerTest, SortServices);
412 FRIEND_TEST(ManagerTest, SortServicesWithConnection);
Paul Stewart10e9e4e2012-04-26 19:46:28 -0700413 FRIEND_TEST(ManagerTest, StartupPortalList);
Darin Petkov6f9eaa32011-08-09 15:26:44 -0700414
Darin Petkovb65c2452012-02-23 15:17:06 +0100415 static const char kErrorNoDevice[];
416 static const char kErrorTypeRequired[];
417 static const char kErrorUnsupportedServiceType[];
418
Darin Petkov3ec55342012-09-28 14:04:44 +0200419 // Time to wait for termination actions to complete.
420 static const int kTerminationActionsTimeoutMilliseconds;
421
422 static const char kPowerManagerKey[];
423
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000424 void AutoConnect();
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800425 std::vector<std::string> AvailableTechnologies(Error *error);
426 std::vector<std::string> ConnectedTechnologies(Error *error);
427 std::string DefaultTechnology(Error *error);
428 std::vector<std::string> EnabledTechnologies(Error *error);
Ben Chan5086b972013-01-15 21:51:38 -0800429 std::vector<std::string> UninitializedTechnologies(Error *error);
Paul Stewartcb3eb892012-06-07 14:24:46 -0700430 RpcIdentifiers EnumerateDevices(Error *error);
431 RpcIdentifiers EnumerateProfiles(Error *error);
Chris Masone6791a432011-07-12 13:23:19 -0700432 // TODO(cmasone): This should be implemented by filtering |services_|.
Paul Stewartcb3eb892012-06-07 14:24:46 -0700433 RpcIdentifiers EnumerateWatchedServices(Error *error);
Paul Stewart1b253142012-01-26 14:05:52 -0800434 std::string GetActiveProfileRpcIdentifier(Error *error);
Paul Stewart10e9e4e2012-04-26 19:46:28 -0700435 std::string GetCheckPortalList(Error *error);
Paul Stewart49739c02012-08-08 17:24:03 -0700436 RpcIdentifier GetDefaultServiceRpcIdentifier(Error *error);
Paul Stewart4d5efb72012-09-17 12:24:34 -0700437 std::string GetIgnoredDNSSearchPaths(Error *error);
Paul Stewart7f5ad572012-06-04 15:18:54 -0700438 ServiceRefPtr GetServiceInner(const KeyValueStore &args, Error *error);
mukesh agrawalbebf1b82013-04-23 15:06:33 -0700439 bool SetCheckPortalList(const std::string &portal_list, Error *error);
440 bool SetIgnoredDNSSearchPaths(const std::string &ignored_paths, Error *error);
Paul Stewart49739c02012-08-08 17:24:03 -0700441 void EmitDefaultService();
Paul Stewart036dba02012-08-07 12:34:41 -0700442 bool IsTechnologyInList(const std::string &technology_list,
443 Technology::Identifier tech) const;
Paul Stewart3c504012013-01-17 17:49:58 -0800444 bool IsDefaultProfile(StoreInterface *storage);
Eric Shienbrood8839a892012-03-29 10:33:48 -0400445 void EmitDeviceProperties();
Chris Masoneb925cc82011-06-22 15:39:57 -0700446
Paul Stewart65512e12012-03-26 18:01:08 -0700447 // Unload a service while iterating through |services_|. Returns true if
448 // service was erased (which means the caller loop should not increment
449 // |service_iterator|), false otherwise (meaning the caller should
450 // increment |service_iterator|).
451 bool UnloadService(std::vector<ServiceRefPtr>::iterator *service_iterator);
452
Paul Stewart4d5efb72012-09-17 12:24:34 -0700453 // Load Manager default properties from |profile|.
454 bool LoadProperties(const scoped_refptr<DefaultProfile> &profile);
455
Paul Stewart3c504012013-01-17 17:49:58 -0800456 // Configure the device with profile data from all current profiles.
457 void LoadDeviceFromProfiles(const DeviceRefPtr &device);
458
Paul Stewart49739c02012-08-08 17:24:03 -0700459 void HelpRegisterConstDerivedRpcIdentifier(
460 const std::string &name,
461 RpcIdentifier(Manager::*get)(Error *));
mukesh agrawal2366eed2012-03-20 18:21:50 -0700462 void HelpRegisterConstDerivedRpcIdentifiers(
463 const std::string &name,
464 RpcIdentifiers(Manager::*get)(Error *));
mukesh agrawalffa3d042011-10-06 15:26:10 -0700465 void HelpRegisterDerivedString(
466 const std::string &name,
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800467 std::string(Manager::*get)(Error *),
mukesh agrawalbebf1b82013-04-23 15:06:33 -0700468 bool(Manager::*set)(const std::string&, Error *));
469 void HelpRegisterConstDerivedStrings(
mukesh agrawalffa3d042011-10-06 15:26:10 -0700470 const std::string &name,
mukesh agrawalbebf1b82013-04-23 15:06:33 -0700471 Strings(Manager::*get)(Error *));
Chris Masone27c4aa52011-07-02 13:10:14 -0700472
Paul Stewartf3eced92013-04-17 12:18:22 -0700473 bool HasProfile(const Profile::Identifier &ident);
474 void PushProfileInternal(const Profile::Identifier &ident,
475 std::string *path,
476 Error *error);
Paul Stewart5dc40aa2011-10-28 19:43:43 -0700477 void PopProfileInternal();
Paul Stewart78af94c2013-04-17 16:02:06 -0700478 void OnProfilesChanged();
479
Paul Stewart22aa71b2011-09-16 12:15:11 -0700480 void SortServices();
Paul Stewartdfa46052012-06-26 09:44:14 -0700481 void SortServicesTask();
Paul Stewart75225512012-01-26 22:51:33 -0800482 bool MatchProfileWithService(const ServiceRefPtr &service);
Paul Stewart22aa71b2011-09-16 12:15:11 -0700483
Paul Stewartd2e1c362013-03-03 19:06:07 -0800484 // Sets the profile of |service| to |profile|, without notifying its
485 // previous profile. Configures a |service| with |args|, then saves
486 // the resulting configuration to |profile|. This method is useful
487 // when copying a service configuration from one profile to another,
488 // or writing a newly created service config to a specific profile.
489 static void SetupServiceInProfile(ServiceRefPtr service,
490 ProfileRefPtr profile,
491 const KeyValueStore &args,
492 Error *error);
493
Paul Stewart39db5ca2013-03-18 14:15:17 -0700494 // For each technology present, connect to the "best" service available,
495 // as determined by sorting all services independent of their current state.
496 void ConnectToBestServicesTask();
497
Darin Petkova5e07ef2012-07-09 14:27:57 +0200498 void NotifyDefaultServiceChanged(const ServiceRefPtr &service);
499
Arman Ugurayab22c162012-10-08 19:08:38 -0700500 // Runs the termination actions. If all actions complete within
501 // |kTerminationActionsTimeoutMilliseconds|, |done| is called with a value of
502 // Error::kSuccess. Otherwise, it is called with Error::kOperationTimeout.
503 void RunTerminationActions(const base::Callback<void(const Error &)> &done);
504
Darin Petkovca621542012-07-25 14:25:56 +0200505 void OnPowerStateChanged(PowerManagerProxyDelegate::SuspendState power_state);
Daniel Erat0818cca2012-12-14 10:16:21 -0800506 void OnSuspendImminent(int suspend_id);
Darin Petkov3ec55342012-09-28 14:04:44 +0200507
Daniel Erat0818cca2012-12-14 10:16:21 -0800508 void OnSuspendActionsComplete(int suspend_id, const Error &error);
Christopher Wiley1057cd72013-02-28 15:21:29 -0800509 void VerifyToEncryptLink(std::string public_key, std::string data,
510 ResultStringCallback cb, const Error &error,
511 bool success);
Darin Petkovca621542012-07-25 14:25:56 +0200512
Thieu Lea20cbc22012-01-09 22:01:43 +0000513 // For unit testing.
514 void set_metrics(Metrics *metrics) { metrics_ = metrics; }
Paul Stewartb87d22b2013-07-29 11:11:37 -0700515 void UpdateProviderMapping();
Thieu Lea20cbc22012-01-09 22:01:43 +0000516
Gary Morainac1bdb42012-02-16 17:42:29 -0800517 // Used by tests to set a mock PowerManager. Takes ownership of
518 // power_manager.
519 void set_power_manager(PowerManager *power_manager) {
520 power_manager_.reset(power_manager);
521 }
522
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000523 EventDispatcher *dispatcher_;
Albert Chaulk0e1cdea2013-02-27 15:32:55 -0800524 const base::FilePath run_path_;
525 const base::FilePath storage_path_;
Chris Masone2ae797d2011-08-23 20:41:00 -0700526 const std::string user_storage_format_;
mukesh agrawald142fd62013-05-01 16:50:57 -0700527 base::FilePath user_profile_list_path_; // Changed in tests.
Paul Stewart0af98bf2011-05-10 17:38:08 -0700528 scoped_ptr<ManagerAdaptorInterface> adaptor_;
Darin Petkov002c58e2012-06-19 02:56:05 +0200529 scoped_ptr<DBusManager> dbus_manager_;
Paul Stewart0af98bf2011-05-10 17:38:08 -0700530 DeviceInfo device_info_;
Darin Petkov887f2982011-07-14 16:10:17 -0700531 ModemInfo modem_info_;
Paul Stewart35eff132013-04-12 12:08:40 -0700532 scoped_ptr<EthernetEapProvider> ethernet_eap_provider_;
Darin Petkovc3505a52013-03-18 15:13:29 +0100533 scoped_ptr<VPNProvider> vpn_provider_;
Paul Stewart3c504012013-01-17 17:49:58 -0800534 scoped_ptr<WiFiProvider> wifi_provider_;
Ben Chan520eb172013-10-30 20:51:04 -0700535#if !defined(DISABLE_WIMAX)
Paul Stewartb87d22b2013-07-29 11:11:37 -0700536 scoped_ptr<WiMaxProvider> wimax_provider_;
Ben Chan520eb172013-10-30 20:51:04 -0700537#endif // DISABLE_WIMAX
Paul Stewart4d5efb72012-09-17 12:24:34 -0700538 // Hold pointer to singleton Resolver instance for testing purposes.
539 Resolver *resolver_;
Paul Stewart75897df2011-04-27 09:05:53 -0700540 bool running_;
Paul Stewart5dc40aa2011-10-28 19:43:43 -0700541 // Used to facilitate unit tests which can't use RPC.
542 bool connect_profiles_to_rpc_;
Chris Masonec1e50412011-06-07 13:04:53 -0700543 std::vector<DeviceRefPtr> devices_;
Chris Masone6791a432011-07-12 13:23:19 -0700544 // We store Services in a vector, because we want to keep them sorted.
Gary Morain028545d2012-04-07 14:55:52 -0700545 // Services that are connected appear first in the vector. See
546 // Service::Compare() for details of the sorting criteria.
Chris Masonec1e50412011-06-07 13:04:53 -0700547 std::vector<ServiceRefPtr> services_;
Paul Stewartb87d22b2013-07-29 11:11:37 -0700548 // Map of technologies to Provider instances. These pointers are owned
549 // by the respective scoped_reptr objects that are held over the lifetime
550 // of the Manager object.
Paul Stewartbc14fb72013-07-30 08:21:58 -0700551 std::map<Technology::Identifier, ProviderInterface *> providers_;
Gaurav Shah71354762011-11-28 19:22:49 -0800552 // List of startup profile names to push on the profile stack on startup.
Chris Masone7aa5f902011-07-11 11:13:35 -0700553 std::vector<ProfileRefPtr> profiles_;
554 ProfileRefPtr ephemeral_profile_;
Chris Masone2ae797d2011-08-23 20:41:00 -0700555 ControlInterface *control_interface_;
Thieu Le3426c8f2012-01-11 17:35:11 -0800556 Metrics *metrics_;
Chris Masone2ae797d2011-08-23 20:41:00 -0700557 GLib *glib_;
Gary Morainac1bdb42012-02-16 17:42:29 -0800558 scoped_ptr<PowerManager> power_manager_;
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700559
Paul Stewart22aa71b2011-09-16 12:15:11 -0700560 // The priority order of technologies
561 std::vector<Technology::Identifier> technology_order_;
562
Paul Stewart49739c02012-08-08 17:24:03 -0700563 // This is the last Service RPC Identifier for which we emitted a
564 // "DefaultService" signal for.
565 RpcIdentifier default_service_rpc_identifier_;
566
Paul Stewart10e9e4e2012-04-26 19:46:28 -0700567 // Manager can be optionally configured with a list of technologies to
568 // do portal detection on at startup. We need to keep track of that list
569 // as well as a flag that tells us whether we should continue using it
570 // instead of the configured portal list.
571 std::string startup_portal_list_;
572 bool use_startup_portal_list_;
573
Chris Masoneb925cc82011-06-22 15:39:57 -0700574 // Properties to be get/set via PropertyStore calls.
Chris Masone88cbd5f2011-07-03 14:30:04 -0700575 Properties props_;
Chris Masone27c4aa52011-07-02 13:10:14 -0700576 PropertyStore store_;
Gary Moraina9fb3252012-05-31 12:05:31 -0700577
Paul Stewartdfa46052012-06-26 09:44:14 -0700578 base::CancelableClosure sort_services_task_;
Darin Petkov3ec55342012-09-28 14:04:44 +0200579
580 // TODO(petkov): Currently this handles both terminate and suspend
581 // actions. Rename all relevant identifiers to capture this.
Gary Moraina9fb3252012-05-31 12:05:31 -0700582 HookTable termination_actions_;
Darin Petkova5e07ef2012-07-09 14:27:57 +0200583
Daniel Erat0818cca2012-12-14 10:16:21 -0800584 // Is a suspend delay currently registered with the power manager?
585 bool suspend_delay_registered_;
586
587 // If |suspend_delay_registered_| is true, contains the unique ID
588 // corresponding to the suspend delay.
589 int suspend_delay_id_;
590
Darin Petkova5e07ef2012-07-09 14:27:57 +0200591 // Maps tags to callbacks for monitoring default service changes.
592 std::map<int, ServiceCallback> default_service_callbacks_;
593 int default_service_callback_tag_;
Christopher Wiley1057cd72013-02-28 15:21:29 -0800594
595 // Delegate to handle destination verification operations for the manager.
596 scoped_ptr<CryptoUtilProxy> crypto_util_proxy_;
Prathmesh Prabhuba99b592013-04-17 15:13:14 -0700597
598 // Stores IP addresses of some remote hosts that accept port 80 TCP
599 // connections. ConnectionHealthChecker uses these IPs.
600 // The store resides in Manager so that it persists across Device reset.
601 scoped_ptr<IPAddressStore> health_checker_remote_ips_;
Paul Stewart7de7e022013-08-28 09:42:50 -0700602
603 // Stores the most recent copy of geolocation information for each
604 // technology type.
605 std::map<std::string, GeolocationInfos> networks_for_geolocation_;
Paul Stewart03e29f72013-09-26 00:49:48 -0700606
607 // Stores the state of the highest ranked connected service.
608 std::string connection_state_;
Paul Stewart75897df2011-04-27 09:05:53 -0700609};
610
611} // namespace shill
612
Darin Petkov002c58e2012-06-19 02:56:05 +0200613#endif // SHILL_MANAGER_H_