blob: 8acd31351911232ab7a877d995c49e7237f5f5a9 [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[];
64 static const char kStorageEapCertID[];
65 static const char kStorageEapClientCert[];
66 static const char kStorageEapEap[];
67 static const char kStorageEapIdentity[];
68 static const char kStorageEapInnerEap[];
69 static const char kStorageEapKeyID[];
70 static const char kStorageEapKeyManagement[];
71 static const char kStorageEapPIN[];
72 static const char kStorageEapPassword[];
73 static const char kStorageEapPrivateKey[];
74 static const char kStorageEapPrivateKeyPassword[];
75 static const char kStorageEapUseSystemCAs[];
76 static const char kStorageError[];
77 static const char kStorageFavorite[];
78 static const char kStorageGUID[];
79 static const char kStorageName[];
80 static const char kStoragePriority[];
81 static const char kStorageProxyConfig[];
82 static const char kStorageSaveCredentials[];
83 static const char kStorageType[];
84 static const char kStorageUIData[];
85
mukesh agrawal8f3f7752012-02-17 19:42:09 -080086 static const uint8 kStrengthMax;
87 static const uint8 kStrengthMin;
88
Paul Stewart75897df2011-04-27 09:05:53 -070089 enum ConnectFailure {
Paul Stewart03dba0b2011-08-22 16:32:45 -070090 kFailureUnknown,
91 kFailureActivationFailure,
92 kFailureOutOfRange,
93 kFailurePinMissing,
94 kFailureConfigurationFailed,
95 kFailureBadCredentials,
96 kFailureNeedEVDO,
97 kFailureNeedHomeNetwork,
98 kFailureOTASPFailure,
Thieu Le48e6d6d2011-12-06 00:40:27 +000099 kFailureAAAFailure,
100 kFailureMax
Paul Stewart75897df2011-04-27 09:05:53 -0700101 };
Chris Masone9be4a9d2011-05-16 15:44:09 -0700102 enum ConnectState {
Paul Stewart03dba0b2011-08-22 16:32:45 -0700103 kStateUnknown,
104 kStateIdle,
105 kStateAssociating,
106 kStateConfiguring,
107 kStateConnected,
108 kStateDisconnected,
Thieu Le48e6d6d2011-12-06 00:40:27 +0000109 kStatePortal,
Gaurav Shahc6d6c722011-11-17 18:59:39 -0800110 kStateFailure,
111 kStateOnline
Chris Masone9be4a9d2011-05-16 15:44:09 -0700112 };
Chris Masoneb2e326b2011-07-12 13:28:51 -0700113 struct EapCredentials {
114 EapCredentials() : use_system_cas(false) {}
115 std::string identity;
116 std::string eap;
117 std::string inner_eap;
118 std::string anonymous_identity;
119 std::string client_cert;
120 std::string cert_id;
121 std::string private_key;
122 std::string private_key_password;
123 std::string key_id;
124 std::string ca_cert;
125 std::string ca_cert_id;
126 bool use_system_cas;
127 std::string pin;
128 std::string password;
129 std::string key_management;
130 };
Chris Masone9be4a9d2011-05-16 15:44:09 -0700131
Paul Stewartac4ac002011-08-26 12:04:26 -0700132 static const int kPriorityNone;
133
Chris Masone9be4a9d2011-05-16 15:44:09 -0700134 // A constructor for the Service object
135 Service(ControlInterface *control_interface,
136 EventDispatcher *dispatcher,
Thieu Le3426c8f2012-01-11 17:35:11 -0800137 Metrics *metrics,
mukesh agrawal7a4e4002011-09-06 11:26:05 -0700138 Manager *manager,
Gaurav Shah435de2c2011-11-17 19:01:07 -0800139 Technology::Identifier technology);
Chris Masone9be4a9d2011-05-16 15:44:09 -0700140 virtual ~Service();
Darin Petkovba40dd32011-07-11 20:06:39 -0700141
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000142 // AutoConnect MAY choose to ignore the connection request in some
143 // cases. For example, if the corresponding Device only supports one
144 // concurrent connection, and another Service is already connected
145 // or connecting.
146 //
147 // AutoConnect MAY issue RPCs immediately. So AutoConnect MUST NOT
148 // be called from a D-Bus signal handler context.
149 virtual void AutoConnect();
150 // Queue up a connection attempt.
mukesh agrawaladb68482012-01-17 16:31:51 -0800151 virtual void Connect(Error *error);
152 // Disconnect this service. The service will not be eligible for
153 // auto-connect until a subsequent call to Connect, or Load.
154 virtual void Disconnect(Error *error);
Chris Masonea82b7112011-05-25 15:16:29 -0700155
Eric Shienbrood5de44ab2011-12-05 10:46:27 -0500156 // The default implementation returns the error kInvalidArguments.
157 virtual void ActivateCellularModem(const std::string &carrier,
Eric Shienbrood9a245532012-03-07 14:20:39 -0500158 Error *error,
159 const ResultCallback &callback);
Darin Petkovc408e692011-08-17 13:47:15 -0700160
Paul Stewart22aa71b2011-09-16 12:15:11 -0700161 // Base method always returns false.
162 virtual bool TechnologyIs(const Technology::Identifier type) const;
163
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800164 virtual bool IsActive(Error *error);
Paul Stewart03dba0b2011-08-22 16:32:45 -0700165
166 virtual ConnectState state() const { return state_; }
167 // Updates the state of the Service and alerts the manager. Also
168 // clears |failure_| if the new state isn't a failure.
169 virtual void SetState(ConnectState state);
170
Paul Stewart22aa71b2011-09-16 12:15:11 -0700171 // State utility functions
Paul Stewart20088d82012-02-16 06:58:55 -0800172 virtual bool IsConnected() const {
173 return state() == kStateConnected || state() == kStatePortal ||
174 state() == kStateOnline;
175 }
Gaurav Shah435de2c2011-11-17 19:01:07 -0800176 virtual bool IsConnecting() const {
Paul Stewart22aa71b2011-09-16 12:15:11 -0700177 return state() == kStateAssociating || state() == kStateConfiguring;
178 }
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000179 virtual bool IsFailed() const {
mukesh agrawal568b5c62012-02-28 14:44:47 -0800180 // We sometimes lie about the failure state, to keep Chrome happy
181 // (see comment in WiFi::HandleDisconnect). Hence, we check both
182 // state and |failed_time_|.
183 return state() == kStateFailure || failed_time_ > 0;
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000184 }
Paul Stewart22aa71b2011-09-16 12:15:11 -0700185
Paul Stewart03dba0b2011-08-22 16:32:45 -0700186 virtual ConnectFailure failure() const { return failure_; }
mukesh agrawal568b5c62012-02-28 14:44:47 -0800187 // Records the failure mode and time. Sets the Service state to "Failure".
Paul Stewart03dba0b2011-08-22 16:32:45 -0700188 virtual void SetFailure(ConnectFailure failure);
mukesh agrawal568b5c62012-02-28 14:44:47 -0800189 // Records the failure mode and time. Sets the Service state to "Idle".
190 // Avoids showing a failure mole in the UI.
191 virtual void SetFailureSilent(ConnectFailure failure);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700192
Darin Petkovba40dd32011-07-11 20:06:39 -0700193 // Returns a string that is guaranteed to uniquely identify this Service
194 // instance.
mukesh agrawald835b202011-10-07 15:26:47 -0700195 const std::string &UniqueName() const { return unique_name_; }
Darin Petkovafa6fc42011-06-21 16:21:08 -0700196
Chris Masone6791a432011-07-12 13:23:19 -0700197 virtual std::string GetRpcIdentifier() const;
Chris Masone3c3f6a12011-07-01 10:01:41 -0700198
Darin Petkovba40dd32011-07-11 20:06:39 -0700199 // Returns the unique persistent storage identifier for the service.
Chris Masone6515aab2011-10-12 16:19:09 -0700200 virtual std::string GetStorageIdentifier() const = 0;
Darin Petkovba40dd32011-07-11 20:06:39 -0700201
Paul Stewartbba6a5b2011-11-02 18:45:59 -0700202 // Returns whether the service configuration can be loaded from |storage|.
203 virtual bool IsLoadableFrom(StoreInterface *storage) const;
204
Darin Petkovba40dd32011-07-11 20:06:39 -0700205 // Loads the service from persistent |storage|. Returns true on success.
Chris Masone9d779932011-08-25 16:33:41 -0700206 virtual bool Load(StoreInterface *storage);
Darin Petkovba40dd32011-07-11 20:06:39 -0700207
Paul Stewarta41e38d2011-11-11 07:47:29 -0800208 // Indicate to service that it is no longer persisted to storage. It
Paul Stewart65512e12012-03-26 18:01:08 -0700209 // should purge any stored profile state (e.g., credentials). Returns
210 // true to indicate that this service should also be unregistered from
211 // the manager, false otherwise.
212 virtual bool Unload();
Paul Stewarta41e38d2011-11-11 07:47:29 -0800213
Darin Petkovba40dd32011-07-11 20:06:39 -0700214 // Saves the service to persistent |storage|. Returns true on success.
Chris Masone9d779932011-08-25 16:33:41 -0700215 virtual bool Save(StoreInterface *storage);
Darin Petkovba40dd32011-07-11 20:06:39 -0700216
Thieu Led4e9e552012-02-16 16:26:07 -0800217 // Saves the service to the current profile.
218 virtual bool SaveToCurrentProfile();
219
Paul Stewartcb59fed2012-03-21 21:14:46 -0700220 // Applies all the properties in |args| to this service object's mutable
221 // store, except for those in parameters_ignored_for_configure_.
222 // Returns an error in |error| if one or more parameter set attempts
223 // fails, but will only return the first error.
224 virtual void Configure(const KeyValueStore &args, Error *error);
225
Paul Stewarta41e38d2011-11-11 07:47:29 -0800226 // Returns true if the service RPC identifier should be part of the
227 // manager's advertised services list, false otherwise.
228 virtual bool IsVisible() const { return true; }
229
Paul Stewart20088d82012-02-16 06:58:55 -0800230 // Returns true if there is a proxy configuration set on this service.
231 virtual bool HasProxyConfig() const { return !proxy_config_.empty(); }
232
mukesh agrawal00917ce2011-11-22 23:56:55 +0000233 virtual void MakeFavorite();
234
Paul Stewartc1dec4d2011-12-08 15:25:28 -0800235 // Set the connection for this service. If the connection is
236 // non-NULL, create an HTTP Proxy that will utilize this service's
237 // connection to serve requests.
238 virtual void SetConnection(ConnectionRefPtr connection);
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800239
Gaurav Shah10109f22011-11-11 20:16:22 -0800240 // Examines the EAP credentials for the service and returns true if a
241 // connection attempt can be made.
242 bool Is8021xConnectable() const;
243
Thieu Le48e6d6d2011-12-06 00:40:27 +0000244 // The inherited class should register any custom metrics in this method.
245 virtual void InitializeCustomMetrics() const {}
246
247 // The inherited class that needs to send metrics after the service has
Thieu Leb84ba342012-03-02 15:15:19 -0800248 // transitioned to the ready state should override this method.
249 // |time_resume_to_ready_milliseconds| holds the elapsed time from when
250 // the system was resumed until when the service transitioned to the
251 // connected state. This value is non-zero for the first service transition
252 // to the connected state after a resume.
253 virtual void SendPostReadyStateMetrics(
254 int64 /*time_resume_to_ready_milliseconds*/) const {}
Thieu Le48e6d6d2011-12-06 00:40:27 +0000255
Darin Petkovafa6fc42011-06-21 16:21:08 -0700256 bool auto_connect() const { return auto_connect_; }
257 void set_auto_connect(bool connect) { auto_connect_ = connect; }
Paul Stewart75897df2011-04-27 09:05:53 -0700258
Gaurav Shah435de2c2011-11-17 19:01:07 -0800259 bool connectable() const { return connectable_; }
mukesh agrawal29c13a12011-11-24 00:09:19 +0000260 void set_connectable(bool connectable);
Gaurav Shah435de2c2011-11-17 19:01:07 -0800261
Thieu Le67370f62012-02-14 23:01:42 +0000262 virtual bool explicitly_disconnected() const {
263 return explicitly_disconnected_;
264 }
265
Paul Stewart22aa71b2011-09-16 12:15:11 -0700266 bool favorite() const { return favorite_; }
mukesh agrawal00917ce2011-11-22 23:56:55 +0000267 // Setter is deliberately omitted; use MakeFavorite.
Paul Stewart22aa71b2011-09-16 12:15:11 -0700268
mukesh agrawal15908392011-11-16 18:29:25 +0000269 const std::string &friendly_name() const { return friendly_name_; }
Darin Petkov7f060332012-03-14 11:46:47 +0100270 void set_friendly_name(const std::string &n) { friendly_name_ = n; }
mukesh agrawal15908392011-11-16 18:29:25 +0000271
Paul Stewart4c561612012-03-21 12:49:01 -0700272 const std::string &guid() const { return guid_; }
273 void set_guid(const std::string &guid) { guid_ = guid; }
274
Paul Stewart22aa71b2011-09-16 12:15:11 -0700275 int32 priority() const { return priority_; }
276 void set_priority(int32 priority) { priority_ = priority; }
277
Paul Stewart1ca3e852011-11-04 07:50:49 -0700278 int32 security_level() const { return security_level_; }
279 void set_security_level(int32 security) { security_level_ = security; }
Paul Stewart22aa71b2011-09-16 12:15:11 -0700280
Darin Petkovd78ee7e2012-01-12 11:21:10 +0100281 void SetStrength(uint8 strength);
mukesh agrawale1d90e92012-02-15 17:36:08 -0800282
283 // uint8 streams out as a char. Coerce to a larger type, so that
284 // it prints as a number.
285 uint16 strength() const { return strength_; }
Paul Stewart22aa71b2011-09-16 12:15:11 -0700286
Gaurav Shah435de2c2011-11-17 19:01:07 -0800287 virtual Technology::Identifier technology() const { return technology_; }
288 std::string GetTechnologyString(Error *error);
289
Gaurav Shah10109f22011-11-11 20:16:22 -0800290 const EapCredentials &eap() const { return eap_; }
291 virtual void set_eap(const EapCredentials &eap);
292
Darin Petkov51489002011-08-18 13:13:20 -0700293 const std::string &error() const { return error_; }
294 void set_error(const std::string &error) { error_ = error; }
295
Gaurav Shahc6d6c722011-11-17 18:59:39 -0800296 static const char *ConnectFailureToString(const ConnectFailure &state);
297 static const char *ConnectStateToString(const ConnectState &state);
298
Paul Stewart22aa71b2011-09-16 12:15:11 -0700299 // Compare two services. Returns true if Service a should be displayed
300 // above Service b
301 static bool Compare(ServiceRefPtr a,
302 ServiceRefPtr b,
mukesh agrawalddc378f2012-02-17 18:26:20 -0800303 const std::vector<Technology::Identifier> &tech_order,
304 const char **reason);
Paul Stewart22aa71b2011-09-16 12:15:11 -0700305
Chris Masone34af2182011-08-22 11:59:36 -0700306 // These are defined in service.cc so that we don't have to include profile.h
Chris Masone9d779932011-08-25 16:33:41 -0700307 // TODO(cmasone): right now, these are here only so that we can get the
308 // profile name as a property. Can we store just the name, and then handle
309 // setting the profile for this service via |manager_|?
Chris Masone6791a432011-07-12 13:23:19 -0700310 const ProfileRefPtr &profile() const;
311 void set_profile(const ProfileRefPtr &p);
312
mukesh agrawalde29fa82011-09-16 16:16:36 -0700313 PropertyStore *mutable_store() { return &store_; }
314 const PropertyStore &store() const { return store_; }
Paul Stewartce4ec192012-03-14 12:53:46 -0700315 virtual const ConnectionRefPtr &connection() const { return connection_; }
Chris Masone27c4aa52011-07-02 13:10:14 -0700316
mukesh agrawalb54601c2011-06-07 17:39:22 -0700317 protected:
Chris Masone34af2182011-08-22 11:59:36 -0700318 // Returns true if a character is allowed to be in a service storage id.
319 static bool LegalChar(char a) { return isalnum(a) || a == '_'; }
320
Darin Petkov31332412012-01-28 01:50:02 +0100321 // Returns true if a character is disallowed to be in a service storage id.
322 static bool IllegalChar(char a) { return !LegalChar(a); }
323
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800324 virtual std::string CalculateState(Error *error);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700325
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000326 // Returns whether this service is in a state conducive to auto-connect.
327 // This should include any tests used for computing connectable(),
328 // as well as other critera such as whether the device associated with
329 // this service is busy with another connection.
mukesh agrawalbf14e942012-03-02 14:36:34 -0800330 //
331 // If the service is not auto-connectable, |*reason| will be set to
332 // point to C-string explaining why the service is not auto-connectable.
333 virtual bool IsAutoConnectable(const char **reason) const;
mukesh agrawal8a3188d2011-12-01 20:56:44 +0000334
mukesh agrawal292dc0f2012-01-26 18:02:46 -0800335 // HelpRegisterDerived*: Expose a property over RPC, with the name |name|.
336 //
337 // Reads of the property will be handled by invoking |get|.
338 // Writes to the property will be handled by invoking |set|.
339 // Clearing the property will be handled by PropertyStore.
mukesh agrawalffa3d042011-10-06 15:26:10 -0700340 void HelpRegisterDerivedBool(
341 const std::string &name,
Hristo Stefanoved2c28c2011-11-29 15:37:30 -0800342 bool(Service::*get)(Error *error),
343 void(Service::*set)(const bool &value, Error *error));
mukesh agrawalffa3d042011-10-06 15:26:10 -0700344 void HelpRegisterDerivedString(
345 const std::string &name,
Hristo Stefanoved2c28c2011-11-29 15:37:30 -0800346 std::string(Service::*get)(Error *error),
347 void(Service::*set)(const std::string &value, Error *error));
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800348 void HelpRegisterDerivedUint16(
349 const std::string &name,
350 uint16(Service::*get)(Error *error),
351 void(Service::*set)(const uint16 &value, Error *error));
Jason Glasgowacdc11f2012-03-30 14:12:22 -0400352 void HelpRegisterDerivedRpcIdentifier(
353 const std::string &name,
354 std::string(Service::*get)(Error *),
355 void(Service::*set)(const RpcIdentifier&, Error *));
mukesh agrawal292dc0f2012-01-26 18:02:46 -0800356 // Expose a property over RPC, with the name |name|.
357 //
358 // Reads of the property will be handled by invoking |get|.
359 // Writes to the property will be handled by invoking |set|.
360 //
361 // Clearing the property will be handled by invoking |clear|, or
362 // calling |set| with |default_value| (whichever is non-NULL). It
363 // is an error to call this method with both |clear| and
364 // |default_value| non-NULL.
365 void HelpRegisterWriteOnlyDerivedString(
366 const std::string &name,
367 void(Service::*set)(const std::string &value, Error *error),
368 void(Service::*clear)(Error *error),
369 const std::string *default_value);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700370
Darin Petkovb72cf402011-11-22 14:51:39 +0100371 ServiceAdaptorInterface *adaptor() const { return adaptor_.get(); }
372
Darin Petkovba40dd32011-07-11 20:06:39 -0700373 // Assigns |value| to |key| in |storage| if |value| is non-empty and |save| is
374 // true. Otherwise, removes |key| from |storage|. If |crypted| is true, the
375 // value is encrypted.
376 void SaveString(StoreInterface *storage,
Chris Masone34af2182011-08-22 11:59:36 -0700377 const std::string &id,
Darin Petkovba40dd32011-07-11 20:06:39 -0700378 const std::string &key,
379 const std::string &value,
380 bool crypted,
381 bool save);
382
Chris Masone34af2182011-08-22 11:59:36 -0700383 void LoadEapCredentials(StoreInterface *storage, const std::string &id);
384 void SaveEapCredentials(StoreInterface *storage, const std::string &id);
Paul Stewartd8ad3c42012-01-09 12:39:38 -0800385 void UnloadEapCredentials();
Darin Petkovba40dd32011-07-11 20:06:39 -0700386
Paul Stewartcb59fed2012-03-21 21:14:46 -0700387 // Ignore |parameter| when performing a Configure() operation.
388 void IgnoreParameterForConfigure(const std::string &parameter);
389
Paul Stewartac4ac002011-08-26 12:04:26 -0700390 // Property accessors reserved for subclasses
391 EventDispatcher *dispatcher() const { return dispatcher_; }
392 const std::string &GetEAPKeyManagement() const;
393 void SetEAPKeyManagement(const std::string &key_management);
Paul Stewart9f32d192012-01-30 20:37:50 -0800394 void SetEAPPassword(const std::string &password, Error *error);
395 void SetEAPPrivateKeyPassword(const std::string &password, Error *error);
Paul Stewart65512e12012-03-26 18:01:08 -0700396 Manager *manager() const { return manager_; }
Thieu Le48e6d6d2011-12-06 00:40:27 +0000397 Metrics *metrics() const { return metrics_; }
mukesh agrawalb54601c2011-06-07 17:39:22 -0700398
Paul Stewart75897df2011-04-27 09:05:53 -0700399 private:
Thieu Le48e6d6d2011-12-06 00:40:27 +0000400 friend class MetricsTest;
Paul Stewart0756db92012-01-27 08:34:47 -0800401 friend class ServiceAdaptorInterface;
mukesh agrawale1d90e92012-02-15 17:36:08 -0800402 friend class WiFiServiceTest;
Paul Stewartcb59fed2012-03-21 21:14:46 -0700403 FRIEND_TEST(ServiceTest, ConfigureIgnoredProperty);
404 FRIEND_TEST(ServiceTest, ConfigureStringProperty);
Darin Petkovba40dd32011-07-11 20:06:39 -0700405 FRIEND_TEST(ServiceTest, Constructor);
Thieu Le284fe792012-01-31 17:53:19 -0800406 FRIEND_TEST(ServiceTest, GetProperties);
mukesh agrawal76d13882012-01-12 15:23:11 -0800407 FRIEND_TEST(ServiceTest, IsAutoConnectable);
Darin Petkovba40dd32011-07-11 20:06:39 -0700408 FRIEND_TEST(ServiceTest, Save);
409 FRIEND_TEST(ServiceTest, SaveString);
410 FRIEND_TEST(ServiceTest, SaveStringCrypted);
411 FRIEND_TEST(ServiceTest, SaveStringDontSave);
412 FRIEND_TEST(ServiceTest, SaveStringEmpty);
mukesh agrawal6bb9e7c2012-01-30 14:57:54 -0800413 FRIEND_TEST(ServiceTest, SetProperty);
mukesh agrawal568b5c62012-02-28 14:44:47 -0800414 FRIEND_TEST(ServiceTest, State);
Paul Stewartd8ad3c42012-01-09 12:39:38 -0800415 FRIEND_TEST(ServiceTest, Unload);
Darin Petkovba40dd32011-07-11 20:06:39 -0700416
mukesh agrawalbf14e942012-03-02 14:36:34 -0800417 static const char kAutoConnConnected[];
418 static const char kAutoConnConnecting[];
419 static const char kAutoConnExplicitDisconnect[];
420 static const char kAutoConnNotConnectable[];
421
mukesh agrawalddc378f2012-02-17 18:26:20 -0800422 static const char kServiceSortConnectEtc[];
423 static const char kServiceSortIsConnected[];
424 static const char kServiceSortIsConnecting[];
425 static const char kServiceSortIsFailed[];
426 static const char kServiceSortTechnology[];
427 static const char kServiceSortSecurityEtc[];
428 static const char kServiceSortUniqueName[];
429
Thieu Le284fe792012-01-31 17:53:19 -0800430 bool GetAutoConnect(Error *error);
431 void SetAutoConnect(const bool &connect, Error *error);
432
Gaurav Shah1b7a6162011-11-09 11:41:01 -0800433 virtual std::string GetDeviceRpcId(Error *error) = 0;
Chris Masone95207da2011-06-29 16:50:49 -0700434
Paul Stewart0c438332012-04-11 07:55:27 -0700435 std::string GetNameProperty(Error *error);
436 void AssertTrivialSetNameProperty(const std::string &name, Error *error);
437
Paul Stewart1b1a7f22012-01-06 16:24:06 -0800438 std::string GetProfileRpcId(Error *error);
439 void SetProfileRpcId(const std::string &profile, Error *error);
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700440
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800441 // Returns TCP port of service's HTTP proxy in host order.
442 uint16 GetHTTPProxyPort(Error *error);
443
Paul Stewart22aa71b2011-09-16 12:15:11 -0700444 // Utility function that returns true if a is different from b. When they
445 // are, "decision" is populated with the boolean value of "a > b".
446 static bool DecideBetween(int a, int b, bool *decision);
447
Thieu Le284fe792012-01-31 17:53:19 -0800448 // For unit testing.
449 void set_favorite(bool favorite) { favorite_ = favorite; }
450
Paul Stewartac4ac002011-08-26 12:04:26 -0700451 ConnectState state_;
452 ConnectFailure failure_;
453 bool auto_connect_;
454 std::string check_portal_;
455 bool connectable_;
456 std::string error_;
mukesh agrawaladb68482012-01-17 16:31:51 -0800457 bool explicitly_disconnected_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700458 bool favorite_;
459 int32 priority_;
Paul Stewart1ca3e852011-11-04 07:50:49 -0700460 int32 security_level_;
Darin Petkovd78ee7e2012-01-12 11:21:10 +0100461 uint8 strength_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700462 std::string proxy_config_;
Paul Stewart987e71e2011-12-05 09:45:06 -0800463 std::string ui_data_;
Paul Stewart4c561612012-03-21 12:49:01 -0700464 std::string guid_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700465 bool save_credentials_;
466 EapCredentials eap_; // Only saved if |save_credentials_| is true.
Gaurav Shah435de2c2011-11-17 19:01:07 -0800467 Technology::Identifier technology_;
mukesh agrawal568b5c62012-02-28 14:44:47 -0800468 // The time of the most recent failure. Value is 0 if the service is
469 // not currently failed.
470 time_t failed_time_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700471
472 ProfileRefPtr profile_;
473 PropertyStore store_;
Paul Stewartcb59fed2012-03-21 21:14:46 -0700474 std::set<std::string> parameters_ignored_for_configure_;
Paul Stewartac4ac002011-08-26 12:04:26 -0700475
476 EventDispatcher *dispatcher_;
mukesh agrawal51a7e932011-07-27 16:18:26 -0700477 static unsigned int serial_number_;
mukesh agrawald835b202011-10-07 15:26:47 -0700478 std::string unique_name_; // MUST be unique amongst service instances
479 std::string friendly_name_; // MAY be same as |unique_name_|
Paul Stewart75897df2011-04-27 09:05:53 -0700480 bool available_;
481 bool configured_;
Paul Stewart75897df2011-04-27 09:05:53 -0700482 Configuration *configuration_;
Paul Stewartba41b992011-05-26 07:02:46 -0700483 scoped_ptr<ServiceAdaptorInterface> adaptor_;
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800484 scoped_ptr<HTTPProxy> http_proxy_;
Paul Stewartc1dec4d2011-12-08 15:25:28 -0800485 ConnectionRefPtr connection_;
Thieu Le3426c8f2012-01-11 17:35:11 -0800486 Metrics *metrics_;
Chris Masone6791a432011-07-12 13:23:19 -0700487 Manager *manager_;
Paul Stewartbe5f5b32011-12-07 17:11:11 -0800488 Sockets sockets_;
Chris Masone3bd3c8c2011-06-13 08:20:26 -0700489
mukesh agrawalb54601c2011-06-07 17:39:22 -0700490 DISALLOW_COPY_AND_ASSIGN(Service);
Paul Stewart75897df2011-04-27 09:05:53 -0700491};
492
493} // namespace shill
494
495#endif // SHILL_SERVICE_