blob: c5ec15d1a5526332aa93ce1b7fd534e1c2e14669 [file] [log] [blame]
// Copyright (C) 2012 The Android Open Source Project
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// See the License for the specific language governing permissions and
// limitations under the License.
#include <memory>
#include <string>
#include <base/cancelable_callback.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 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 {
: public Device {
#endif // DISABLE_WIRED_8021X
Ethernet(ControlInterface* control_interface,
EventDispatcher* dispatcher,
Metrics* metrics,
Manager* manager,
const std::string& link_name,
const std::string& 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(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 std::string& BSS,
const KeyValueStore& properties) override;
void BSSRemoved(const std::string& 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;
void TDLSDiscoverResponse(const std::string& peer_address) override;
#endif // DISABLE_WIRED_8021X
virtual bool link_up() const { return link_up_; }
friend class EthernetTest;
friend class EthernetServiceTest; // For weak_ptr_factory_.
friend class PPPoEServiceTest; // For weak_ptr_factory_.
#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();
#endif // DISABLE_WIRED_8021X
// Accessors for the PPoE property.
bool GetPPPoEMode(Error* error);
bool ConfigurePPPoEMode(const bool& mode, Error* error);
void ClearPPPoEMode(Error* error);
// Helpers for creating services with |this| as their device.
EthernetServiceRefPtr CreateEthernetService();
EthernetServiceRefPtr CreatePPPoEService();
void SetupWakeOnLan();
ControlInterface* control_interface_;
EthernetServiceRefPtr service_;
bool link_up_;
#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<SupplicantProcessProxyInterface> supplicant_process_proxy_;
std::string supplicant_interface_path_;
std::string 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_;
base::WeakPtrFactory<Ethernet> weak_ptr_factory_;
} // namespace shill