| // Copyright 2018 The Chromium OS Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef SHILL_ETHERNET_ETHERNET_H_ |
| #define SHILL_ETHERNET_ETHERNET_H_ |
| |
| #include <cstdint> |
| #include <memory> |
| #include <string> |
| |
| #include <base/cancelable_callback.h> |
| #include <base/files/file_path.h> |
| #include <base/memory/weak_ptr.h> |
| |
| #include "shill/certificate_file.h" |
| #include "shill/device.h" |
| #include "shill/event_dispatcher.h" |
| #include "shill/refptr_types.h" |
| |
| #if !defined(DISABLE_WIRED_8021X) |
| #include "shill/key_value_store.h" |
| #include "shill/supplicant/supplicant_eap_state_handler.h" |
| #include "shill/supplicant/supplicant_event_delegate_interface.h" |
| #endif // DISABLE_WIRED_8021X |
| |
| namespace shill { |
| |
| class EthernetProvider; |
| class Sockets; |
| class StoreInterface; |
| |
| #if !defined(DISABLE_WIRED_8021X) |
| class CertificateFile; |
| class EapListener; |
| class EthernetEapProvider; |
| class SupplicantEAPStateHandler; |
| class SupplicantInterfaceProxyInterface; |
| class SupplicantProcessProxyInterface; |
| #endif // DISABLE_WIRED_8021X |
| |
| class Ethernet |
| #if !defined(DISABLE_WIRED_8021X) |
| : public Device, |
| public SupplicantEventDelegateInterface { |
| #else |
| : public Device { |
| #endif // DISABLE_WIRED_8021X |
| public: |
| Ethernet(Manager* manager, |
| const std::string& link_name, |
| const std::string& mac_address, |
| int interface_index); |
| ~Ethernet() override; |
| |
| void Start(Error* error, |
| const EnabledStateChangedCallback& callback) override; |
| void Stop(Error* error, const EnabledStateChangedCallback& callback) override; |
| void LinkEvent(unsigned int flags, unsigned int change) override; |
| bool Load(const StoreInterface* storage) override; |
| bool Save(StoreInterface* storage) override; |
| |
| virtual void ConnectTo(EthernetService* service); |
| virtual void DisconnectFrom(EthernetService* service); |
| |
| #if !defined(DISABLE_WIRED_8021X) |
| // Test to see if conditions are correct for EAP authentication (both |
| // credentials and a remote EAP authenticator is present) and initiate |
| // an authentication if possible. |
| virtual void TryEapAuthentication(); |
| |
| // Implementation of SupplicantEventDelegateInterface. These methods |
| // are called by SupplicantInterfaceProxy, in response to events from |
| // wpa_supplicant. |
| void BSSAdded(const RpcIdentifier& BSS, |
| const KeyValueStore& properties) override; |
| void BSSRemoved(const RpcIdentifier& BSS) override; |
| void Certification(const KeyValueStore& properties) override; |
| void EAPEvent(const std::string& status, |
| const std::string& parameter) override; |
| void PropertiesChanged(const KeyValueStore& properties) override; |
| void ScanDone(const bool& /*success*/) override; |
| #endif // DISABLE_WIRED_8021X |
| |
| std::string GetStorageIdentifier() const override; |
| |
| virtual bool link_up() const { return link_up_; } |
| |
| const std::string& permanent_mac_address() const { |
| return permanent_mac_address_; |
| } |
| |
| private: |
| friend class EthernetTest; |
| friend class EthernetServiceTest; // For weak_ptr_factory_. |
| friend class PPPoEServiceTest; // For weak_ptr_factory_. |
| |
| FRIEND_TEST(EthernetProviderTest, MultipleServices); |
| |
| // Return a pointer to the EthernetProvider for Ethernet devices. |
| EthernetProvider* GetProvider(); |
| |
| #if !defined(DISABLE_WIRED_8021X) |
| // Return a pointer to the EAP provider for Ethernet devices. |
| EthernetEapProvider* GetEapProvider(); |
| |
| // Return a reference to the shared service that contains EAP credentials |
| // for Ethernet. |
| ServiceConstRefPtr GetEapService(); |
| |
| // Invoked by |eap_listener_| when an EAP authenticator is detected. |
| void OnEapDetected(); |
| |
| // Start and stop a supplicant instance on this link. |
| bool StartSupplicant(); |
| void StopSupplicant(); |
| |
| // Start the EAP authentication process. |
| bool StartEapAuthentication(); |
| |
| // Change our EAP authentication state. |
| void SetIsEapAuthenticated(bool is_eap_authenticated); |
| |
| // Callback tasks run as a result of event delegate methods. |
| void CertificationTask(const std::string& subject, uint32_t depth); |
| void EAPEventTask(const std::string& status, const std::string& parameter); |
| void SupplicantStateChangedTask(const std::string& state); |
| |
| // Callback task run as a result of TryEapAuthentication(). |
| void TryEapAuthenticationTask(); |
| |
| SupplicantProcessProxyInterface* supplicant_process_proxy() const; |
| #endif // DISABLE_WIRED_8021X |
| |
| // Accessors for the PPoE property. |
| bool GetPPPoEMode(Error* error); |
| bool ConfigurePPPoEMode(const bool& mode, Error* error); |
| void ClearPPPoEMode(Error* error); |
| |
| // Accessors for the UsbEthernetMacAddressSource property. |
| std::string GetUsbEthernetMacAddressSource(Error* error); |
| |
| // Helpers for creating services with |this| as their device. |
| EthernetServiceRefPtr CreateEthernetService(); |
| EthernetServiceRefPtr CreatePPPoEService(); |
| |
| void RegisterService(EthernetServiceRefPtr service); |
| void DeregisterService(EthernetServiceRefPtr service); |
| |
| void SetupWakeOnLan(); |
| |
| void SetUsbEthernetMacAddressSource(const std::string& source, |
| Error* error, |
| const ResultCallback& callback) override; |
| |
| // Returns hex coded MAC address in lower case and without colons on success. |
| // Otherwise returns an empty string. |
| virtual std::string ReadMacAddressFromFile(const base::FilePath& file_path); |
| |
| // Callback for when netlink sends response on SetInterfaceMac. |
| // It runs |callback| with on success or failure. Updates Ethernet MAC address |
| // if |error == 0|; |
| void OnSetInterfaceMacResponse(const std::string& mac_address_source, |
| const std::string& new_mac_address, |
| const ResultCallback& callback, |
| int32_t error); |
| // Sets new MAC address and reconnects to the |service_| to renew IP address |
| // if needed. |
| void set_mac_address(const std::string& mac_address) override; |
| |
| // Queries the kernel for a permanent MAC address. Returns a permanent MAC |
| // address in lower case on success. Otherwise returns an empty string. |
| std::string GetPermanentMacAddressFromKernel(); |
| |
| // Returns device bus type on success. Otherwise, returns empty string. |
| std::string GetDeviceBusType() const; |
| |
| EthernetServiceRefPtr service_; |
| bool link_up_; |
| |
| std::string usb_ethernet_mac_address_source_; |
| |
| std::string bus_type_; |
| |
| #if !defined(DISABLE_WIRED_8021X) |
| // Track whether we have completed EAP authentication successfully. |
| bool is_eap_authenticated_; |
| |
| // Track whether an EAP authenticator has been detected on this link. |
| bool is_eap_detected_; |
| std::unique_ptr<EapListener> eap_listener_; |
| |
| // Track the progress of EAP authentication. |
| SupplicantEAPStateHandler eap_state_handler_; |
| |
| // Proxy instances used to talk to wpa_supplicant. |
| std::unique_ptr<SupplicantInterfaceProxyInterface> |
| supplicant_interface_proxy_; |
| RpcIdentifier supplicant_interface_path_; |
| RpcIdentifier supplicant_network_path_; |
| |
| // Certificate file instance to generate public key data for remote |
| // authentication. |
| CertificateFile certificate_file_; |
| |
| // Make sure TryEapAuthenticationTask is only queued for execution once |
| // at a time. |
| base::CancelableClosure try_eap_authentication_callback_; |
| #endif // DISABLE_WIRED_8021X |
| |
| std::unique_ptr<Sockets> sockets_; |
| |
| std::string permanent_mac_address_; |
| |
| base::WeakPtrFactory<Ethernet> weak_ptr_factory_; |
| |
| DISALLOW_COPY_AND_ASSIGN(Ethernet); |
| }; |
| |
| } // namespace shill |
| |
| #endif // SHILL_ETHERNET_ETHERNET_H_ |