chromeos/network/network_connection_handler.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef CHROMEOS_NETWORK_NETWORK_CONNECTION_HANDLER_H_
   6 #define CHROMEOS_NETWORK_NETWORK_CONNECTION_HANDLER_H_
   7
   8 #include <set>
   9 #include <string>
  10
  11 #include "base/basictypes.h"
  12 #include "base/callback.h"
  13 #include "base/memory/weak_ptr.h"
  14 #include "base/values.h"
  15 #include "chromeos/cert_loader.h"
  16 #include "chromeos/chromeos_export.h"
  17 #include "chromeos/dbus/dbus_method_call_status.h"
  18 #include "chromeos/login/login_state.h"
  19 #include "chromeos/network/network_handler.h"
  20 #include "chromeos/network/network_handler_callbacks.h"
  21 #include "chromeos/network/network_state_handler_observer.h"
  22
  23 namespace chromeos {
  24
  25 class NetworkState;
  26 class NetworkUIData;
  27
  28 // The NetworkConnectionHandler class is used to manage network connection
  29 // requests. This is the only class that should make Shill Connect calls.
  30 // It handles the following steps:
  31 // 1. Determine whether or not sufficient information (e.g. passphrase) is
  32 //    known to be available to connect to the network.
  33 // 2. Request additional information (e.g. user data which contains certificate
  34 //    information) and determine whether sufficient information is available.
  35 // 3. Possibly configure the network certificate info (tpm slot and pkcs11 id).
  36 // 4. Send the connect request.
  37 // 5. Wait for the network state to change to a non connecting state.
  38 // 6. Invoke the appropriate callback (always) on success or failure.
  39 //
  40 // NetworkConnectionHandler depends on NetworkStateHandler for immediately
  41 // available State information, and NetworkConfigurationHandler for any
  42 // configuration calls.
  43
  44 class CHROMEOS_EXPORT NetworkConnectionHandler
  45     : public LoginState::Observer,
  46       public CertLoader::Observer,
  47       public NetworkStateHandlerObserver,
  48       public base::SupportsWeakPtr<NetworkConnectionHandler> {
  49  public:
  50   // Constants for |error_name| from |error_callback| for Connect.
  51
  52   //  No network matching |service_path| is found (hidden networks must be
  53   //  configured before connecting).
  54   static const char kErrorNotFound[];
  55
  56   // Already connected to the network.
  57   static const char kErrorConnected[];
  58
  59   // Already connecting to the network.
  60   static const char kErrorConnecting[];
  61
  62   // The passphrase is missing or invalid.
  63   static const char kErrorPassphraseRequired[];
  64
  65   static const char kErrorActivationRequired[];
  66
  67   // The network requires a cert and none exists.
  68   static const char kErrorCertificateRequired[];
  69
  70   // The network had an authentication error, indicating that additional or
  71   // different authentication information is required.
  72   static const char kErrorAuthenticationRequired[];
  73
  74   // Additional configuration is required.
  75   static const char kErrorConfigurationRequired[];
  76
  77   // Configuration failed during the configure stage of the connect flow.
  78   static const char kErrorConfigureFailed[];
  79
  80   // For Disconnect or Activate, an unexpected DBus or Shill error occurred.
  81   static const char kErrorShillError[];
  82
  83   // A new network connect request canceled this one.
  84   static const char kErrorConnectCanceled[];
  85
  86   // Constants for |error_name| from |error_callback| for Disconnect.
  87   static const char kErrorNotConnected[];
  88
  89   virtual ~NetworkConnectionHandler();
  90
  91   // ConnectToNetwork() will start an asynchronous connection attempt.
  92   // On success, |success_callback| will be called.
  93   // On failure, |error_callback| will be called with |error_name| one of the
  94   //   constants defined above, or shill::kErrorConnectFailed or
  95   //   shill::kErrorBadPassphrase if the Shill Error property (from a
  96   //   previous connect attempt) was set to one of those.
  97   // |error_message| will contain an additional error string for debugging.
  98   // If |check_error_state| is true, the current state of the network is
  99   //  checked for errors, otherwise current state is ignored (e.g. for recently
 100   //  configured networks or repeat attempts).
 101   void ConnectToNetwork(const std::string& service_path,
 102                         const base::Closure& success_callback,
 103                         const network_handler::ErrorCallback& error_callback,
 104                         bool check_error_state);
 105
 106   // DisconnectNetwork() will send a Disconnect request to Shill.
 107   // On success, |success_callback| will be called.
 108   // On failure, |error_callback| will be called with |error_name| one of:
 109   //  kErrorNotFound if no network matching |service_path| is found.
 110   //  kErrorNotConnected if not connected to the network.
 111   //  kErrorShillError if a DBus or Shill error occurred.
 112   // |error_message| will contain and additional error string for debugging.
 113   void DisconnectNetwork(const std::string& service_path,
 114                          const base::Closure& success_callback,
 115                          const network_handler::ErrorCallback& error_callback);
 116
 117   // Returns true if ConnectToNetwork has been called with |service_path| and
 118   // has not completed (i.e. success or error callback has been called).
 119   bool HasConnectingNetwork(const std::string& service_path);
 120
 121   // Returns true if there are any pending connect requests.
 122   bool HasPendingConnectRequest();
 123
 124   // NetworkStateHandlerObserver
 125   virtual void NetworkListChanged() OVERRIDE;
 126   virtual void NetworkPropertiesUpdated(const NetworkState* network) OVERRIDE;
 127
 128   // LoginState::Observer
 129   virtual void LoggedInStateChanged() OVERRIDE;
 130
 131   // CertLoader::Observer
 132   virtual void OnCertificatesLoaded(const net::CertificateList& cert_list,
 133                                     bool initial_load) OVERRIDE;
 134
 135  private:
 136   friend class NetworkHandler;
 137   friend class NetworkConnectionHandlerTest;
 138
 139   struct ConnectRequest;
 140
 141   NetworkConnectionHandler();
 142
 143   void Init(NetworkStateHandler* network_state_handler,
 144             NetworkConfigurationHandler* network_configuration_handler);
 145
 146   ConnectRequest* GetPendingRequest(const std::string& service_path);
 147
 148   // Callback from Shill.Service.GetProperties. Parses |properties| to verify
 149   // whether or not the network appears to be configured. If configured,
 150   // attempts a connection, otherwise invokes error_callback from
 151   // pending_requests_[service_path]. |check_error_state| is passed from
 152   // ConnectToNetwork(), see comment for info.
 153   void VerifyConfiguredAndConnect(bool check_error_state,
 154                                   const std::string& service_path,
 155                                   const base::DictionaryValue& properties);
 156
 157   // Calls Shill.Manager.Connect asynchronously.
 158   void CallShillConnect(const std::string& service_path);
 159
 160   // Handle failure from ConfigurationHandler calls.
 161   void HandleConfigurationFailure(
 162       const std::string& service_path,
 163       const std::string& error_name,
 164       scoped_ptr<base::DictionaryValue> error_data);
 165
 166   // Handle success or failure from Shill.Service.Connect.
 167   void HandleShillConnectSuccess(const std::string& service_path);
 168   void HandleShillConnectFailure(const std::string& service_path,
 169                                  const std::string& error_name,
 170                                  const std::string& error_message);
 171
 172   void CheckPendingRequest(const std::string service_path);
 173   void CheckAllPendingRequests();
 174
 175   // Returns the PKCS#11 ID of a cert matching the certificate pattern in
 176   // |ui_data|. Returns empty string otherwise.
 177   std::string CertificateIsConfigured(NetworkUIData* ui_data);
 178   void ErrorCallbackForPendingRequest(const std::string& service_path,
 179                                       const std::string& error_name);
 180
 181   // Calls Shill.Manager.Disconnect asynchronously.
 182   void CallShillDisconnect(
 183       const std::string& service_path,
 184       const base::Closure& success_callback,
 185       const network_handler::ErrorCallback& error_callback);
 186
 187   // Handle success from Shill.Service.Disconnect.
 188   void HandleShillDisconnectSuccess(const std::string& service_path,
 189                                     const base::Closure& success_callback);
 190
 191
 192   // Local references to the associated handler instances.
 193   CertLoader* cert_loader_;
 194   NetworkStateHandler* network_state_handler_;
 195   NetworkConfigurationHandler* network_configuration_handler_;
 196
 197   // Map of pending connect requests, used to prevent repeated attempts while
 198   // waiting for Shill and to trigger callbacks on eventual success or failure.
 199   std::map<std::string, ConnectRequest> pending_requests_;
 200   scoped_ptr<ConnectRequest> queued_connect_;
 201
 202   // Track certificate loading state.
 203   bool logged_in_;
 204   bool certificates_loaded_;
 205
 206   DISALLOW_COPY_AND_ASSIGN(NetworkConnectionHandler);
 207 };
 208
 209 }  // namespace chromeos
 210
 211 #endif  // CHROMEOS_NETWORK_NETWORK_CONNECTION_HANDLER_H_