blob: 14a6286a03c87fed9b9a1aaf1fee42751697dcb6 [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
Chris Masone9be4a9d2011-05-16 15:44:09 -07005#ifndef SHILL_SERVICE_
6#define SHILL_SERVICE_
Paul Stewart75897df2011-04-27 09:05:53 -07007
mukesh agrawal568b5c62012-02-28 14:44:47 -08008#include <time.h>
9
Chris Masone9be4a9d2011-05-16 15:44:09 -070010#include <string>
Chris Masone8fe2c7e2011-06-09 15:51:19 -070011#include <map>
Paul Stewartcb59fed2012-03-21 21:14:46 -070012#include <set>
Chris Masone8fe2c7e2011-06-09 15:51:19 -070013#include <vector>
Chris Masone9be4a9d2011-05-16 15:44:09 -070014
15#include <base/memory/ref_counted.h>
Paul Stewartba41b992011-05-26 07:02:46 -070016#include <base/memory/scoped_ptr.h>
Darin Petkovba40dd32011-07-11 20:06:39 -070017#include <gtest/gtest_prod.h> // for FRIEND_TEST
Paul Stewart75897df2011-04-27 09:05:53 -070018
Eric Shienbrood9a245532012-03-07 14:20:39 -050019#include "shill/adaptor_interfaces.h"
Chris Masone3bd3c8c2011-06-13 08:20:26 -070020#include "shill/accessor_interface.h"
Eric Shienbrood9a245532012-03-07 14:20:39 -050021#include "shill/callbacks.h"
Chris Masoneb925cc82011-06-22 15:39:57 -070022#include "shill/property_store.h"
Chris Masone7aa5f902011-07-11 11:13:35 -070023#include "shill/refptr_types.h"
Paul Stewartbe5f5b32011-12-07 17:11:11 -080024#include "shill/sockets.h"
Paul Stewart22aa71b2011-09-16 12:15:11 -070025#include "shill/technology.h"
Chris Masonec1e50412011-06-07 13:04:53 -070026
Thieu Leb84ba342012-03-02 15:15:19 -080027namespace chromeos_metrics {
28class Timer;
29}
30
Paul Stewart75897df2011-04-27 09:05:53 -070031namespace shill {
32
Paul Stewart75897df2011-04-27 09:05:53 -070033class Configuration;
Chris Masone9be4a9d2011-05-16 15:44:09 -070034class ControlInterface;
Paul Stewart75897df2011-04-27 09:05:53 -070035class Endpoint;
Chris Masone8fe2c7e2011-06-09 15:51:19 -070036class Error;
Chris Masone9be4a9d2011-05-16 15:44:09 -070037class EventDispatcher;
Paul Stewartbe5f5b32011-12-07 17:11:11 -080038class HTTPProxy;
mukesh agrawal7a4e4002011-09-06 11:26:05 -070039class KeyValueStore;
Chris Masone6791a432011-07-12 13:23:19 -070040class Manager;
Thieu Le48e6d6d2011-12-06 00:40:27 +000041class Metrics;
Chris Masone9be4a9d2011-05-16 15:44:09 -070042class ServiceAdaptorInterface;
Darin Petkovba40dd32011-07-11 20:06:39 -070043class StoreInterface;
Paul Stewart75897df2011-04-27 09:05:53 -070044
Chris Masone7aa5f902011-07-11 11:13:35 -070045// A Service is a uniquely named entity, which the system can
46// connect in order to begin sending and receiving network traffic.
47// All Services are bound to an Entry, which represents the persistable
48// state of the Service. If the Entry is populated at the time of Service
49// creation, that information is used to prime the Service. If not, the Entry
50// becomes populated over time.
Chris Masone27c4aa52011-07-02 13:10:14 -070051class Service : public base::RefCounted<Service> {
Paul Stewart75897df2011-04-27 09:05:53 -070052 public:
Darin Petkovba40dd32011-07-11 20:06:39 -070053 static const char kCheckPortalAuto[];
54 static const char kCheckPortalFalse[];
55 static const char kCheckPortalTrue[];
56
Paul Stewart0756db92012-01-27 08:34:47 -080057 // TODO(pstew): Storage constants shouldn't need to be public
58 // crosbug.com/25813
59 static const char kStorageAutoConnect[];
60 static const char kStorageCheckPortal[];
61 static const char kStorageEapAnonymousIdentity[];
62 static const char kStorageEapCACert[];
63 static const char kStorageEapCACertID[];
Paul Stewartecf4cd12012-04-17 11:08:39 -070064 static const char kStorageEapCACertNSS[];
Paul Stewart0756db92012-01-27 08:34:47 -080065 static const char kStorageEapCertID[];
66 static const char kStorageEapClientCert[];
67 static const char kStorageEapEap[];
68 static const char kStorageEapIdentity[];
69 static const char kStorageEapInnerEap[];
70 static const char kStorageEapKeyID[];
71 static const char kStorageEapKeyManagement[];
72 static const char kStorageEapPIN[];
73 static const char kStorageEapPassword[];
74 static const char kStorageEapPrivateKey[];
75 static const char kStorageEapPrivateKeyPassword[];
76 static const char kStorageEapUseSystemCAs[];
77 static const char kStorageError[];
78 static const char kStorageFavorite[];
79 static const char kStorageGUID[];
80 static const char kStorageName[];
81 static const char kStoragePriority[];
82 static const char kStorageProxyConfig[];
83 static const char kStorageSaveCredentials[];
84 static const char kStorageType[];
85 static const char kStorageUIData[];
86
mukesh agrawal8f3f7752012-02-17 19:42:09 -080087 static const uint8 kStrengthMax;
88 static const uint8 kStrengthMin;
89
Paul Stewart75897df2011-04-27 09:05:53 -070090 enum ConnectFailure {
Paul Stewart03dba0b2011-08-22 16:32:45 -070091 kFailureUnknown,
92 kFailureActivationFailure,
93 kFailureOutOfRange,
94 kFailurePinMissing,
95 kFailureConfigurationFailed,
96 kFailureBadCredentials,
97 kFailureNeedEVDO,
98 kFailureNeedHomeNetwork,
99 kFailureOTASPFailure,
Thieu Le48e6d6d2011-12-06 00:40:27 +0000100 kFailureAAAFailure,
101 kFailureMax
Paul Stewart75897df2011-04-27 09:05:53 -0700102 };
Chris Masone9be4a9d2011-05-16 15:44:09 -0700103 enum ConnectState {
Paul Stewart03dba0b2011-08-22 16:32:45 -0700104 kStateUnknown,
105 kStateIdle,
106 kStateAssociating,
107 kStateConfiguring,
108 kStateConnected,
109 kStateDisconnected,
Thieu Le48e6d6d2011-12-06 00:40:27 +0000110 kStatePortal,
Gaurav Shahc6d6c722011-11-17 18:59:39 -0800111 kStateFailure,
112 kStateOnline
Chris Masone9be4a9d2011-05-16 15:44:09 -0700113 };
Chris Masoneb2e326b2011-07-12 13:28:51 -0700114 struct EapCredentials {
Paul Stewart20550982012-04-16 12:16:11 -0700115 EapCredentials() : use_system_cas(true) {}
Chris Masoneb2e326b2011-07-12 13:28:51 -0700116 std::string identity;
117 std::string eap;
118 std::string inner_eap;
119 std::string anonymous_identity;
120 std::string client_cert;
121 std::string cert_id;
122 std::string private_key;
123 std::string private_key_password;
124 std::string key_id;
125 std::string ca_cert;
126 std::string ca_cert_id;
Paul Stewartecf4cd12012-04-17 11:08:39 -0700127 std::string ca_cert_nss;
Chris Masoneb2e326b2011-07-12 13:28:51 -0700128 bool use_system_cas;
129 std::string pin;
130 std::string password;
131 std::string key_management;
132 };
Chris Masone9be4a9d2011-05-16 15:44:09 -0700133
Paul Stewartac4ac002011-08-26 12:04:26 -0700134 static const int kPriorityNone;
135
Chris Masone9be4a9d2011-05-16 15:44:09 -0700136 // A constructor for the Service object
137 Service(ControlInterface *control_interface,
138 EventDispatcher *dispatcher,
Thieu Le3426c8f2012-01-11 17:35:11 -0800139 Metrics *metrics,
mukesh agrawal7a4e4002011-09-06 11:26:05 -0700140 Manager *manager,
Gaurav Shah435de2c2011-11-17 19:01:07 -0800141 Technology::Identifier technology);
Chris Masone9be4a9d2011-05-16 15:44:09 -0700142 virtual ~Service();
Darin Petkovba40dd32011-07-11 20:06:39 -0700143
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000144 // AutoConnect MAY choose to ignore the connection request in some
145 // cases. For example, if the corresponding Device only supports one
146 // concurrent connection, and another Service is already connected
147 // or connecting.
148 //
149 // AutoConnect MAY issue RPCs immediately. So AutoConnect MUST NOT
150 // be called from a D-Bus signal handler context.
151 virtual void AutoConnect();
152 // Queue up a connection attempt.
mukesh agrawaladb68482012-01-17 16:31:51 -0800153 virtual void Connect(Error *error);
154 // Disconnect this service. The service will not be eligible for
155 // auto-connect until a subsequent call to Connect, or Load.
156 virtual void Disconnect(Error *error);
Chris Masonea82b7112011-05-25 15:16:29 -0700157
Eric Shienbrood5de44ab2011-12-05 10:46:27 -0500158 // The default implementation returns the error kInvalidArguments.
159 virtual void ActivateCellularModem(const std::string &carrier,
Eric Shienbrood9a245532012-03-07 14:20:39 -0500160 Error *error,
161 const ResultCallback &callback);
Darin Petkovc408e692011-08-17 13:47:15 -0700162
Paul Stewart22aa71b2011-09-16 12:15:11 -0700163 // Base method always returns false.
164 virtual bool TechnologyIs(const Technology::Identifier type) const;
165
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800166 virtual bool IsActive(Error *error);
Paul Stewart03dba0b2011-08-22 16:32:45 -0700167
168 virtual ConnectState state() const { return state_; }
169 // Updates the state of the Service and alerts the manager. Also
170 // clears |failure_| if the new state isn't a failure.
171 virtual void SetState(ConnectState state);
172
Paul Stewart22aa71b2011-09-16 12:15:11 -0700173 // State utility functions
Paul Stewart20088d82012-02-16 06:58:55 -0800174 virtual bool IsConnected() const {
175 return state() == kStateConnected || state() == kStatePortal ||
176 state() == kStateOnline;
177 }
Gaurav Shah435de2c2011-11-17 19:01:07 -0800178 virtual bool IsConnecting() const {
Paul Stewart22aa71b2011-09-16 12:15:11 -0700179 return state() == kStateAssociating || state() == kStateConfiguring;
180 }
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000181 virtual bool IsFailed() const {
mukesh agrawal568b5c62012-02-28 14:44:47 -0800182 // We sometimes lie about the failure state, to keep Chrome happy
183 // (see comment in WiFi::HandleDisconnect). Hence, we check both
184 // state and |failed_time_|.
185 return state() == kStateFailure || failed_time_ > 0;
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000186 }
Paul Stewart22aa71b2011-09-16 12:15:11 -0700187
Paul Stewart03dba0b2011-08-22 16:32:45 -0700188 virtual ConnectFailure failure() const { return failure_; }
mukesh agrawal568b5c62012-02-28 14:44:47 -0800189 // Records the failure mode and time. Sets the Service state to "Failure".
Paul Stewart03dba0b2011-08-22 16:32:45 -0700190 virtual void SetFailure(ConnectFailure failure);
mukesh agrawal568b5c62012-02-28 14:44:47 -0800191 // Records the failure mode and time. Sets the Service state to "Idle".
192 // Avoids showing a failure mole in the UI.
193 virtual void SetFailureSilent(ConnectFailure failure);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700194
Darin Petkovba40dd32011-07-11 20:06:39 -0700195 // Returns a string that is guaranteed to uniquely identify this Service
196 // instance.
mukesh agrawald835b202011-10-07 15:26:47 -0700197 const std::string &UniqueName() const { return unique_name_; }
Darin Petkovafa6fc42011-06-21 16:21:08 -0700198
Chris Masone6791a432011-07-12 13:23:19 -0700199 virtual std::string GetRpcIdentifier() const;
Chris Masone3c3f6a12011-07-01 10:01:41 -0700200
Darin Petkovba40dd32011-07-11 20:06:39 -0700201 // Returns the unique persistent storage identifier for the service.
Chris Masone6515aab2011-10-12 16:19:09 -0700202 virtual std::string GetStorageIdentifier() const = 0;
Darin Petkovba40dd32011-07-11 20:06:39 -0700203
Paul Stewartbba6a5b2011-11-02 18:45:59 -0700204 // Returns whether the service configuration can be loaded from |storage|.
205 virtual bool IsLoadableFrom(StoreInterface *storage) const;
206
Darin Petkovba40dd32011-07-11 20:06:39 -0700207 // Loads the service from persistent |storage|. Returns true on success.
Chris Masone9d779932011-08-25 16:33:41 -0700208 virtual bool Load(StoreInterface *storage);
Darin Petkovba40dd32011-07-11 20:06:39 -0700209
Paul Stewarta41e38d2011-11-11 07:47:29 -0800210 // Indicate to service that it is no longer persisted to storage. It
Paul Stewart65512e12012-03-26 18:01:08 -0700211 // should purge any stored profile state (e.g., credentials). Returns
212 // true to indicate that this service should also be unregistered from
213 // the manager, false otherwise.
214 virtual bool Unload();
Paul Stewarta41e38d2011-11-11 07:47:29 -0800215
Darin Petkovba40dd32011-07-11 20:06:39 -0700216 // Saves the service to persistent |storage|. Returns true on success.
Chris Masone9d779932011-08-25 16:33:41 -0700217 virtual bool Save(StoreInterface *storage);
Darin Petkovba40dd32011-07-11 20:06:39 -0700218
Thieu Led4e9e552012-02-16 16:26:07 -0800219 // Saves the service to the current profile.
220 virtual bool SaveToCurrentProfile();
221
Paul Stewartcb59fed2012-03-21 21:14:46 -0700222 // Applies all the properties in |args| to this service object's mutable
223 // store, except for those in parameters_ignored_for_configure_.
224 // Returns an error in |error| if one or more parameter set attempts
225 // fails, but will only return the first error.
226 virtual void Configure(const KeyValueStore &args, Error *error);
227
Paul Stewartd215af62012-04-24 23:25:50 -0700228 // Returns whether portal detection is explicitly disabled on this service
229 // via a property set on it.
230 virtual bool IsPortalDetectionDisabled() const;
231
232 // Returns whether portal detection is set to follow the default setting
233 // of this service's technology via a property set on it.
234 virtual bool IsPortalDetectionAuto() const;
235
Paul Stewarta41e38d2011-11-11 07:47:29 -0800236 // Returns true if the service RPC identifier should be part of the
237 // manager's advertised services list, false otherwise.
238 virtual bool IsVisible() const { return true; }
239
Paul Stewart20088d82012-02-16 06:58:55 -0800240 // Returns true if there is a proxy configuration set on this service.
241 virtual bool HasProxyConfig() const { return !proxy_config_.empty(); }
242
mukesh agrawal00917ce2011-11-22 23:56:55 +0000243 virtual void MakeFavorite();
244
Paul Stewartc1dec4d2011-12-08 15:25:28 -0800245 // Set the connection for this service. If the connection is
246 // non-NULL, create an HTTP Proxy that will utilize this service's
247 // connection to serve requests.
248 virtual void SetConnection(ConnectionRefPtr connection);
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800249
Gaurav Shah10109f22011-11-11 20:16:22 -0800250 // Examines the EAP credentials for the service and returns true if a
251 // connection attempt can be made.
252 bool Is8021xConnectable() const;
253
Thieu Le48e6d6d2011-12-06 00:40:27 +0000254 // The inherited class should register any custom metrics in this method.
255 virtual void InitializeCustomMetrics() const {}
256
257 // The inherited class that needs to send metrics after the service has
Thieu Leb84ba342012-03-02 15:15:19 -0800258 // transitioned to the ready state should override this method.
259 // |time_resume_to_ready_milliseconds| holds the elapsed time from when
260 // the system was resumed until when the service transitioned to the
261 // connected state. This value is non-zero for the first service transition
262 // to the connected state after a resume.
263 virtual void SendPostReadyStateMetrics(
264 int64 /*time_resume_to_ready_milliseconds*/) const {}
Thieu Le48e6d6d2011-12-06 00:40:27 +0000265
Darin Petkovafa6fc42011-06-21 16:21:08 -0700266 bool auto_connect() const { return auto_connect_; }
267 void set_auto_connect(bool connect) { auto_connect_ = connect; }
Paul Stewart75897df2011-04-27 09:05:53 -0700268
Gaurav Shah435de2c2011-11-17 19:01:07 -0800269 bool connectable() const { return connectable_; }
mukesh agrawal29c13a12011-11-24 00:09:19 +0000270 void set_connectable(bool connectable);
Gaurav Shah435de2c2011-11-17 19:01:07 -0800271
Thieu Le67370f62012-02-14 23:01:42 +0000272 virtual bool explicitly_disconnected() const {
273 return explicitly_disconnected_;
274 }
275
Paul Stewart22aa71b2011-09-16 12:15:11 -0700276 bool favorite() const { return favorite_; }
mukesh agrawal00917ce2011-11-22 23:56:55 +0000277 // Setter is deliberately omitted; use MakeFavorite.
Paul Stewart22aa71b2011-09-16 12:15:11 -0700278
mukesh agrawal15908392011-11-16 18:29:25 +0000279 const std::string &friendly_name() const { return friendly_name_; }
Darin Petkov7f060332012-03-14 11:46:47 +0100280 void set_friendly_name(const std::string &n) { friendly_name_ = n; }
mukesh agrawal15908392011-11-16 18:29:25 +0000281
Paul Stewart4c561612012-03-21 12:49:01 -0700282 const std::string &guid() const { return guid_; }
283 void set_guid(const std::string &guid) { guid_ = guid; }
284
Paul Stewart22aa71b2011-09-16 12:15:11 -0700285 int32 priority() const { return priority_; }
286 void set_priority(int32 priority) { priority_ = priority; }
287
Paul Stewart1ca3e852011-11-04 07:50:49 -0700288 int32 security_level() const { return security_level_; }
289 void set_security_level(int32 security) { security_level_ = security; }
Paul Stewart22aa71b2011-09-16 12:15:11 -0700290
Darin Petkovd78ee7e2012-01-12 11:21:10 +0100291 void SetStrength(uint8 strength);
mukesh agrawale1d90e92012-02-15 17:36:08 -0800292
293 // uint8 streams out as a char. Coerce to a larger type, so that
294 // it prints as a number.
295 uint16 strength() const { return strength_; }
Paul Stewart22aa71b2011-09-16 12:15:11 -0700296
Gaurav Shah435de2c2011-11-17 19:01:07 -0800297 virtual Technology::Identifier technology() const { return technology_; }
298 std::string GetTechnologyString(Error *error);
299
Gaurav Shah10109f22011-11-11 20:16:22 -0800300 const EapCredentials &eap() const { return eap_; }
301 virtual void set_eap(const EapCredentials &eap);
302
Darin Petkovcb715292012-04-25 13:04:37 +0200303 bool save_credentials() const { return save_credentials_; }
304 void set_save_credentials(bool save) { save_credentials_ = save; }
305
Darin Petkov51489002011-08-18 13:13:20 -0700306 const std::string &error() const { return error_; }
307 void set_error(const std::string &error) { error_ = error; }
308
Gaurav Shahc6d6c722011-11-17 18:59:39 -0800309 static const char *ConnectFailureToString(const ConnectFailure &state);
310 static const char *ConnectStateToString(const ConnectState &state);
311
Paul Stewart22aa71b2011-09-16 12:15:11 -0700312 // Compare two services. Returns true if Service a should be displayed
313 // above Service b
314 static bool Compare(ServiceRefPtr a,
315 ServiceRefPtr b,
mukesh agrawalddc378f2012-02-17 18:26:20 -0800316 const std::vector<Technology::Identifier> &tech_order,
317 const char **reason);
Paul Stewart22aa71b2011-09-16 12:15:11 -0700318
Chris Masone34af2182011-08-22 11:59:36 -0700319 // These are defined in service.cc so that we don't have to include profile.h
Chris Masone9d779932011-08-25 16:33:41 -0700320 // TODO(cmasone): right now, these are here only so that we can get the
321 // profile name as a property. Can we store just the name, and then handle
322 // setting the profile for this service via |manager_|?
Chris Masone6791a432011-07-12 13:23:19 -0700323 const ProfileRefPtr &profile() const;
324 void set_profile(const ProfileRefPtr &p);
325
Paul Stewartff14b022012-04-24 20:06:23 -0700326 // Notification that occurs when a single property has been changed via
327 // the RPC adaptor.
328 void OnPropertyChanged(const std::string &property);
329
mukesh agrawalde29fa82011-09-16 16:16:36 -0700330 PropertyStore *mutable_store() { return &store_; }
331 const PropertyStore &store() const { return store_; }
Paul Stewartce4ec192012-03-14 12:53:46 -0700332 virtual const ConnectionRefPtr &connection() const { return connection_; }
Chris Masone27c4aa52011-07-02 13:10:14 -0700333
mukesh agrawalb54601c2011-06-07 17:39:22 -0700334 protected:
Chris Masone34af2182011-08-22 11:59:36 -0700335 // Returns true if a character is allowed to be in a service storage id.
336 static bool LegalChar(char a) { return isalnum(a) || a == '_'; }
337
Darin Petkov31332412012-01-28 01:50:02 +0100338 // Returns true if a character is disallowed to be in a service storage id.
339 static bool IllegalChar(char a) { return !LegalChar(a); }
340
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800341 virtual std::string CalculateState(Error *error);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700342
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000343 // Returns whether this service is in a state conducive to auto-connect.
344 // This should include any tests used for computing connectable(),
345 // as well as other critera such as whether the device associated with
346 // this service is busy with another connection.
mukesh agrawalbf14e942012-03-02 14:36:34 -0800347 //
348 // If the service is not auto-connectable, |*reason| will be set to
349 // point to C-string explaining why the service is not auto-connectable.
350 virtual bool IsAutoConnectable(const char **reason) const;
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000351
mukesh agrawal292dc0f2012-01-26 18:02:46 -0800352 // HelpRegisterDerived*: Expose a property over RPC, with the name |name|.
353 //
354 // Reads of the property will be handled by invoking |get|.
355 // Writes to the property will be handled by invoking |set|.
356 // Clearing the property will be handled by PropertyStore.
mukesh agrawalffa3d042011-10-06 15:26:10 -0700357 void HelpRegisterDerivedBool(
358 const std::string &name,
Hristo Stefanoved2c28c2011-11-29 15:37:30 -0800359 bool(Service::*get)(Error *error),
360 void(Service::*set)(const bool &value, Error *error));
mukesh agrawalffa3d042011-10-06 15:26:10 -0700361 void HelpRegisterDerivedString(
362 const std::string &name,
Hristo Stefanoved2c28c2011-11-29 15:37:30 -0800363 std::string(Service::*get)(Error *error),
364 void(Service::*set)(const std::string &value, Error *error));
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800365 void HelpRegisterDerivedUint16(
366 const std::string &name,
367 uint16(Service::*get)(Error *error),
368 void(Service::*set)(const uint16 &value, Error *error));
Jason Glasgowacdc11f2012-03-30 14:12:22 -0400369 void HelpRegisterDerivedRpcIdentifier(
370 const std::string &name,
371 std::string(Service::*get)(Error *),
372 void(Service::*set)(const RpcIdentifier&, Error *));
mukesh agrawal292dc0f2012-01-26 18:02:46 -0800373 // Expose a property over RPC, with the name |name|.
374 //
375 // Reads of the property will be handled by invoking |get|.
376 // Writes to the property will be handled by invoking |set|.
377 //
378 // Clearing the property will be handled by invoking |clear|, or
379 // calling |set| with |default_value| (whichever is non-NULL). It
380 // is an error to call this method with both |clear| and
381 // |default_value| non-NULL.
382 void HelpRegisterWriteOnlyDerivedString(
383 const std::string &name,
384 void(Service::*set)(const std::string &value, Error *error),
385 void(Service::*clear)(Error *error),
386 const std::string *default_value);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700387
Darin Petkovb72cf402011-11-22 14:51:39 +0100388 ServiceAdaptorInterface *adaptor() const { return adaptor_.get(); }
389
Darin Petkovba40dd32011-07-11 20:06:39 -0700390 // Assigns |value| to |key| in |storage| if |value| is non-empty and |save| is
391 // true. Otherwise, removes |key| from |storage|. If |crypted| is true, the
392 // value is encrypted.
393 void SaveString(StoreInterface *storage,
Chris Masone34af2182011-08-22 11:59:36 -0700394 const std::string &id,
Darin Petkovba40dd32011-07-11 20:06:39 -0700395 const std::string &key,
396 const std::string &value,
397 bool crypted,
398 bool save);
399
Chris Masone34af2182011-08-22 11:59:36 -0700400 void LoadEapCredentials(StoreInterface *storage, const std::string &id);
401 void SaveEapCredentials(StoreInterface *storage, const std::string &id);
Paul Stewartd8ad3c42012-01-09 12:39:38 -0800402 void UnloadEapCredentials();
Darin Petkovba40dd32011-07-11 20:06:39 -0700403
Paul Stewartcb59fed2012-03-21 21:14:46 -0700404 // Ignore |parameter| when performing a Configure() operation.
405 void IgnoreParameterForConfigure(const std::string &parameter);
406
Paul Stewartac4ac002011-08-26 12:04:26 -0700407 // Property accessors reserved for subclasses
408 EventDispatcher *dispatcher() const { return dispatcher_; }
409 const std::string &GetEAPKeyManagement() const;
410 void SetEAPKeyManagement(const std::string &key_management);
Paul Stewart9f32d192012-01-30 20:37:50 -0800411 void SetEAPPassword(const std::string &password, Error *error);
412 void SetEAPPrivateKeyPassword(const std::string &password, Error *error);
Paul Stewart65512e12012-03-26 18:01:08 -0700413 Manager *manager() const { return manager_; }
Thieu Le48e6d6d2011-12-06 00:40:27 +0000414 Metrics *metrics() const { return metrics_; }
mukesh agrawalb54601c2011-06-07 17:39:22 -0700415
Paul Stewart75897df2011-04-27 09:05:53 -0700416 private:
Thieu Le48e6d6d2011-12-06 00:40:27 +0000417 friend class MetricsTest;
Paul Stewart0756db92012-01-27 08:34:47 -0800418 friend class ServiceAdaptorInterface;
mukesh agrawale1d90e92012-02-15 17:36:08 -0800419 friend class WiFiServiceTest;
Paul Stewartcb59fed2012-03-21 21:14:46 -0700420 FRIEND_TEST(ServiceTest, ConfigureIgnoredProperty);
421 FRIEND_TEST(ServiceTest, ConfigureStringProperty);
Darin Petkovba40dd32011-07-11 20:06:39 -0700422 FRIEND_TEST(ServiceTest, Constructor);
Paul Stewart10241e32012-04-23 18:15:06 -0700423 FRIEND_TEST(ServiceTest, GetIPConfigRpcIdentifier);
Thieu Le284fe792012-01-31 17:53:19 -0800424 FRIEND_TEST(ServiceTest, GetProperties);
mukesh agrawal76d13882012-01-12 15:23:11 -0800425 FRIEND_TEST(ServiceTest, IsAutoConnectable);
Paul Stewartd215af62012-04-24 23:25:50 -0700426 FRIEND_TEST(ServiceTest, RecheckPortal);
Darin Petkovba40dd32011-07-11 20:06:39 -0700427 FRIEND_TEST(ServiceTest, Save);
428 FRIEND_TEST(ServiceTest, SaveString);
429 FRIEND_TEST(ServiceTest, SaveStringCrypted);
430 FRIEND_TEST(ServiceTest, SaveStringDontSave);
431 FRIEND_TEST(ServiceTest, SaveStringEmpty);
mukesh agrawal6bb9e7c2012-01-30 14:57:54 -0800432 FRIEND_TEST(ServiceTest, SetProperty);
Paul Stewartd215af62012-04-24 23:25:50 -0700433 FRIEND_TEST(ServiceTest, SetCheckPortal);
mukesh agrawal568b5c62012-02-28 14:44:47 -0800434 FRIEND_TEST(ServiceTest, State);
Paul Stewartd8ad3c42012-01-09 12:39:38 -0800435 FRIEND_TEST(ServiceTest, Unload);
Darin Petkov2f903b32012-04-18 12:56:43 +0200436 FRIEND_TEST(VPNServiceTest, ConnectAlreadyConnected);
Darin Petkovba40dd32011-07-11 20:06:39 -0700437
mukesh agrawalbf14e942012-03-02 14:36:34 -0800438 static const char kAutoConnConnected[];
439 static const char kAutoConnConnecting[];
440 static const char kAutoConnExplicitDisconnect[];
441 static const char kAutoConnNotConnectable[];
442
Darin Petkov2f903b32012-04-18 12:56:43 +0200443 static const char kServiceSortAutoConnect[];
444 static const char kServiceSortConnectable[];
445 static const char kServiceSortFavorite[];
mukesh agrawalddc378f2012-02-17 18:26:20 -0800446 static const char kServiceSortIsConnected[];
447 static const char kServiceSortIsConnecting[];
448 static const char kServiceSortIsFailed[];
Darin Petkov2f903b32012-04-18 12:56:43 +0200449 static const char kServiceSortPriority[];
mukesh agrawalddc378f2012-02-17 18:26:20 -0800450 static const char kServiceSortSecurityEtc[];
Darin Petkov2f903b32012-04-18 12:56:43 +0200451 static const char kServiceSortTechnology[];
mukesh agrawalddc378f2012-02-17 18:26:20 -0800452 static const char kServiceSortUniqueName[];
453
Thieu Le284fe792012-01-31 17:53:19 -0800454 bool GetAutoConnect(Error *error);
455 void SetAutoConnect(const bool &connect, Error *error);
456
Paul Stewartd215af62012-04-24 23:25:50 -0700457 std::string GetCheckPortal(Error *error);
458 void SetCheckPortal(const std::string &check_portal, Error *error);
459
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800460 virtual std::string GetDeviceRpcId(Error *error) = 0;
Chris Masone95207da2011-06-29 16:50:49 -0700461
Paul Stewart10241e32012-04-23 18:15:06 -0700462 std::string GetIPConfigRpcIdentifier(Error *error);
463
Paul Stewart0c438332012-04-11 07:55:27 -0700464 std::string GetNameProperty(Error *error);
465 void AssertTrivialSetNameProperty(const std::string &name, Error *error);
466
Paul Stewart1b1a7f22012-01-06 16:24:06 -0800467 std::string GetProfileRpcId(Error *error);
468 void SetProfileRpcId(const std::string &profile, Error *error);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700469
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800470 // Returns TCP port of service's HTTP proxy in host order.
471 uint16 GetHTTPProxyPort(Error *error);
472
Paul Stewart22aa71b2011-09-16 12:15:11 -0700473 // Utility function that returns true if a is different from b. When they
474 // are, "decision" is populated with the boolean value of "a > b".
475 static bool DecideBetween(int a, int b, bool *decision);
476
Thieu Le284fe792012-01-31 17:53:19 -0800477 // For unit testing.
478 void set_favorite(bool favorite) { favorite_ = favorite; }
479
Paul Stewartac4ac002011-08-26 12:04:26 -0700480 ConnectState state_;
481 ConnectFailure failure_;
482 bool auto_connect_;
483 std::string check_portal_;
484 bool connectable_;
485 std::string error_;
mukesh agrawaladb68482012-01-17 16:31:51 -0800486 bool explicitly_disconnected_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700487 bool favorite_;
488 int32 priority_;
Paul Stewart1ca3e852011-11-04 07:50:49 -0700489 int32 security_level_;
Darin Petkovd78ee7e2012-01-12 11:21:10 +0100490 uint8 strength_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700491 std::string proxy_config_;
Paul Stewart987e71e2011-12-05 09:45:06 -0800492 std::string ui_data_;
Paul Stewart4c561612012-03-21 12:49:01 -0700493 std::string guid_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700494 bool save_credentials_;
495 EapCredentials eap_; // Only saved if |save_credentials_| is true.
Gaurav Shah435de2c2011-11-17 19:01:07 -0800496 Technology::Identifier technology_;
mukesh agrawal568b5c62012-02-28 14:44:47 -0800497 // The time of the most recent failure. Value is 0 if the service is
498 // not currently failed.
499 time_t failed_time_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700500
501 ProfileRefPtr profile_;
502 PropertyStore store_;
Paul Stewartcb59fed2012-03-21 21:14:46 -0700503 std::set<std::string> parameters_ignored_for_configure_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700504
505 EventDispatcher *dispatcher_;
mukesh agrawal51a7e932011-07-27 16:18:26 -0700506 static unsigned int serial_number_;
mukesh agrawald835b202011-10-07 15:26:47 -0700507 std::string unique_name_; // MUST be unique amongst service instances
508 std::string friendly_name_; // MAY be same as |unique_name_|
Paul Stewart75897df2011-04-27 09:05:53 -0700509 bool available_;
510 bool configured_;
Paul Stewart75897df2011-04-27 09:05:53 -0700511 Configuration *configuration_;
Paul Stewartba41b992011-05-26 07:02:46 -0700512 scoped_ptr<ServiceAdaptorInterface> adaptor_;
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800513 scoped_ptr<HTTPProxy> http_proxy_;
Paul Stewartc1dec4d2011-12-08 15:25:28 -0800514 ConnectionRefPtr connection_;
Thieu Le3426c8f2012-01-11 17:35:11 -0800515 Metrics *metrics_;
Chris Masone6791a432011-07-12 13:23:19 -0700516 Manager *manager_;
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800517 Sockets sockets_;
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700518
mukesh agrawalb54601c2011-06-07 17:39:22 -0700519 DISALLOW_COPY_AND_ASSIGN(Service);
Paul Stewart75897df2011-04-27 09:05:53 -0700520};
521
522} // namespace shill
523
524#endif // SHILL_SERVICE_