1//
2// Copyright (C) 2012 The Android Open Source Project
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8//      http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15//
16
17#ifndef SHILL_ETHERNET_ETHERNET_H_
18#define SHILL_ETHERNET_ETHERNET_H_
19
20#include <map>
21#include <memory>
22#include <string>
23
24#include <base/cancelable_callback.h>
25#include <base/memory/weak_ptr.h>
26
27#include "shill/certificate_file.h"
28#include "shill/device.h"
29#include "shill/event_dispatcher.h"
30#include "shill/refptr_types.h"
31
32#if !defined(DISABLE_WIRED_8021X)
33#include "shill/key_value_store.h"
34#include "shill/supplicant/supplicant_eap_state_handler.h"
35#include "shill/supplicant/supplicant_event_delegate_interface.h"
36#endif  // DISABLE_WIRED_8021X
37
38namespace shill {
39
40class Sockets;
41class StoreInterface;
42
43#if !defined(DISABLE_WIRED_8021X)
44class CertificateFile;
45class EapListener;
46class EthernetEapProvider;
47class SupplicantEAPStateHandler;
48class SupplicantInterfaceProxyInterface;
49class SupplicantProcessProxyInterface;
50#endif  // DISABLE_WIRED_8021X
51
52class Ethernet
53#if !defined(DISABLE_WIRED_8021X)
54    : public Device, public SupplicantEventDelegateInterface {
55#else
56    : public Device {
57#endif  // DISABLE_WIRED_8021X
58 public:
59  Ethernet(ControlInterface* control_interface,
60           EventDispatcher* dispatcher,
61           Metrics* metrics,
62           Manager* manager,
63           const std::string& link_name,
64           const std::string& address,
65           int interface_index);
66  ~Ethernet() override;
67
68  void Start(Error* error,
69             const EnabledStateChangedCallback& callback) override;
70  void Stop(Error* error, const EnabledStateChangedCallback& callback) override;
71  void LinkEvent(unsigned int flags, unsigned int change) override;
72  bool Load(StoreInterface* storage) override;
73  bool Save(StoreInterface* storage) override;
74
75  virtual void ConnectTo(EthernetService* service);
76  virtual void DisconnectFrom(EthernetService* service);
77
78#if !defined(DISABLE_WIRED_8021X)
79  // Test to see if conditions are correct for EAP authentication (both
80  // credentials and a remote EAP authenticator is present) and initiate
81  // an authentication if possible.
82  virtual void TryEapAuthentication();
83
84  // Implementation of SupplicantEventDelegateInterface.  These methods
85  // are called by SupplicantInterfaceProxy, in response to events from
86  // wpa_supplicant.
87  void BSSAdded(
88      const std::string& BSS,
89      const KeyValueStore& properties) override;
90  void BSSRemoved(const std::string& BSS) override;
91  void Certification(const KeyValueStore& properties) override;
92  void EAPEvent(const std::string& status,
93                const std::string& parameter) override;
94  void PropertiesChanged(const KeyValueStore& properties) override;
95  void ScanDone(const bool& /*success*/) override;
96  void TDLSDiscoverResponse(const std::string& peer_address) override;
97#endif  // DISABLE_WIRED_8021X
98
99  virtual bool link_up() const { return link_up_; }
100
101 private:
102  friend class EthernetTest;
103  friend class EthernetServiceTest;  // For weak_ptr_factory_.
104  friend class PPPoEServiceTest;     // For weak_ptr_factory_.
105
106#if !defined(DISABLE_WIRED_8021X)
107  // Return a pointer to the EAP provider for Ethernet devices.
108  EthernetEapProvider* GetEapProvider();
109
110  // Return a reference to the shared service that contains EAP credentials
111  // for Ethernet.
112  ServiceConstRefPtr GetEapService();
113
114  // Invoked by |eap_listener_| when an EAP authenticator is detected.
115  void OnEapDetected();
116
117  // Start and stop a supplicant instance on this link.
118  bool StartSupplicant();
119  void StopSupplicant();
120
121  // Start the EAP authentication process.
122  bool StartEapAuthentication();
123
124  // Change our EAP authentication state.
125  void SetIsEapAuthenticated(bool is_eap_authenticated);
126
127  // Callback tasks run as a result of event delegate methods.
128  void CertificationTask(const std::string& subject, uint32_t depth);
129  void EAPEventTask(const std::string& status, const std::string& parameter);
130  void SupplicantStateChangedTask(const std::string& state);
131
132  // Callback task run as a result of TryEapAuthentication().
133  void TryEapAuthenticationTask();
134#endif  // DISABLE_WIRED_8021X
135
136  // Accessors for the PPoE property.
137  bool GetPPPoEMode(Error* error);
138  bool ConfigurePPPoEMode(const bool& mode, Error* error);
139  void ClearPPPoEMode(Error* error);
140
141  // Helpers for creating services with |this| as their device.
142  EthernetServiceRefPtr CreateEthernetService();
143  EthernetServiceRefPtr CreatePPPoEService();
144
145  void SetupWakeOnLan();
146
147  ControlInterface* control_interface_;
148
149  EthernetServiceRefPtr service_;
150  bool link_up_;
151
152#if !defined(DISABLE_WIRED_8021X)
153  // Track whether we have completed EAP authentication successfully.
154  bool is_eap_authenticated_;
155
156  // Track whether an EAP authenticator has been detected on this link.
157  bool is_eap_detected_;
158  std::unique_ptr<EapListener> eap_listener_;
159
160  // Track the progress of EAP authentication.
161  SupplicantEAPStateHandler eap_state_handler_;
162
163  // Proxy instances used to talk to wpa_supplicant.
164  std::unique_ptr<SupplicantProcessProxyInterface> supplicant_process_proxy_;
165  std::unique_ptr<SupplicantInterfaceProxyInterface>
166      supplicant_interface_proxy_;
167  std::string supplicant_interface_path_;
168  std::string supplicant_network_path_;
169
170  // Certificate file instance to generate public key data for remote
171  // authentication.
172  CertificateFile certificate_file_;
173
174  // Make sure TryEapAuthenticationTask is only queued for execution once
175  // at a time.
176  base::CancelableClosure try_eap_authentication_callback_;
177#endif  // DISABLE_WIRED_8021X
178
179  std::unique_ptr<Sockets> sockets_;
180
181  base::WeakPtrFactory<Ethernet> weak_ptr_factory_;
182
183  DISALLOW_COPY_AND_ASSIGN(Ethernet);
184};
185
186}  // namespace shill
187
188#endif  // SHILL_ETHERNET_ETHERNET_H_
189