shill/ethernet/ethernet.cc

// Copyright 2018 The ChromiumOS Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "shill/ethernet/ethernet.h"

#include <linux/ethtool.h>
#include <linux/sockios.h>
#include <string.h>

#include <memory>
#include <optional>
#include <set>
#include <string_view>
#include <utility>

#include <base/check.h>
#include <base/containers/fixed_flat_map.h>
#include <base/containers/fixed_flat_set.h>
#include <base/files/file_path.h>
#include <base/files/file_util.h>
#include <base/functional/bind.h>
#include <base/location.h>
#include <base/logging.h>
#include <base/notreached.h>
#include <base/strings/string_number_conversions.h>
#include <base/strings/string_util.h>
#include <base/strings/stringprintf.h>
#include <chromeos/dbus/shill/dbus-constants.h>
#include <net-base/mac_address.h>

#include "shill/adaptor_interfaces.h"
#include "shill/control_interface.h"
#include "shill/device.h"
#include "shill/device_id.h"
#include "shill/device_info.h"
#include "shill/eap_credentials.h"
#include "shill/ethernet/eap_listener.h"
#include "shill/ethernet/ethernet_eap_provider.h"
#include "shill/ethernet/ethernet_provider.h"
#include "shill/ethernet/ethernet_service.h"
#include "shill/event_dispatcher.h"
#include "shill/logging.h"
#include "shill/manager.h"
#include "shill/profile.h"
#include "shill/refptr_types.h"
#include "shill/store/property_accessor.h"
#include "shill/store/store_interface.h"
#include "shill/supplicant/supplicant_interface_proxy_interface.h"
#include "shill/supplicant/supplicant_manager.h"
#include "shill/supplicant/supplicant_process_proxy_interface.h"
#include "shill/supplicant/wpa_supplicant.h"

namespace shill {

namespace Logging {
static auto kModuleLogScope = ScopeLogger::kEthernet;
static std::string ObjectID(const Ethernet* e) {
  return e->GetRpcIdentifier().value();
}
}  // namespace Logging

namespace {

// Path to file with |ethernet_mac0| VPD field value.
constexpr char kVpdEthernetMacFilePath[] = "/sys/firmware/vpd/ro/ethernet_mac0";
// Path to file with |dock_mac| VPD field value.
constexpr char kVpdDockMacFilePath[] = "/sys/firmware/vpd/ro/dock_mac";

// Constant used to notify metrics of failed attempt to get ethernet driver name
// from ETHTOOL.
constexpr char kEthernetDriverNameError[] = "error";

// kDriverNameSize represents maximal length of driver name, this number is
// taken from definition of driver field of ethtool_dvrinfo struct.
constexpr int kDriverNameSize = 32;

// Factor used to convert mbps to kbps.
constexpr uint32_t kMbpsToKbpsFactor = 1e3;

// NETDEV_FEATURE_COUNT in kernel is < 60 in 5.10 kernel, and has 64 as upper
// bound (since netdev_features_t is typedef'ed to u64 in kernel).
#define MAX_FEATURE_COUNT 64

// This represents the maximum number of u32 blocks needed to store a bit mask
// for all available features (This is similar to ETHTOOL_DEV_FEATURE_WORDS in
// kernel).
#define MAX_FEATURE_BLOCKS ((MAX_FEATURE_COUNT + 31) / 32)
// Features that need to be disabled on potentially untrusted devices. Please
// see go/disable-offloading-features for more context. Feature Strings are
// taken from netdev_features_strings[] in kernel.
constexpr std::array<const char*, 6> kFeaturesToDisable = {
    "tx-generic-segmentation",       // NETIF_F_GSO (aka ethtool's gso feature)
    "rx-gro",                        // NETIF_F_GRO (aka ethtool's gro feature)
    "tx-tcp-segmentation",           // NETIF_F_TSO_ECN (part of ethtool's tso)
    "tx-tcp-ecn-segmentation",       // NETIF_F_TSO (part of ethtool's tso)
    "tx-tcp-mangleid-segmentation",  // NETIF_F_TSO_MANGLEID (ethtools's tso)
    "tx-tcp6-segmentation",          // NETIF_F_TSO6 (part of ethtool's tso)
};

// The BIOS / firmware marks the external facing PCI ports with a special
// "external-facing" tag. That is used by the kernel to determine whether
// a PCI device is attached to an internal port or external port. Please
// note that not all platforms shall be able to distinguish between internal /
// external PCI devices (because this needs BIOS/firmware changes). However
// any platforms that support external PCI devices (i.e. thunderbolt / USB4)
// shall be able to (since those shall be new platforms hence forward).
static bool IsExternalPciDev(const std::string& ifname) {
  auto device_id = DeviceId::CreateFromSysfs(base::FilePath(
      base::StringPrintf("/sys/class/net/%s/device", ifname.c_str())));

  constexpr DeviceId kPciDevicePattern{DeviceId::BusType::kPci,
                                       DeviceId::LocationType::kExternal};
  return (device_id && device_id->Match(kPciDevicePattern));
}

}  // namespace

Ethernet::Ethernet(Manager* manager,
                   const std::string& link_name,
                   std::optional<net_base::MacAddress> mac_address,
                   int interface_index)
    : Device(manager,
             link_name,
             mac_address,
             interface_index,
             Technology::kEthernet),
      link_up_(false),
      bus_type_(GetDeviceBusType()),
      is_eap_authenticated_(false),
      is_eap_detected_(false),
      eap_listener_(std::make_unique<EapListener>(interface_index, link_name)),
      weak_ptr_factory_(this) {
  PropertyStore* store = this->mutable_store();
  store->RegisterConstBool(kEapAuthenticationCompletedProperty,
                           &is_eap_authenticated_);
  store->RegisterConstBool(kEapAuthenticatorDetectedProperty,
                           &is_eap_detected_);
  store->RegisterConstBool(kLinkUpProperty, &link_up_);
  store->RegisterConstString(kDeviceBusTypeProperty, &bus_type_);
  store->RegisterDerivedString(
      kUsbEthernetMacAddressSourceProperty,
      StringAccessor(std::make_unique<CustomAccessor<Ethernet, std::string>>(
          this, &Ethernet::GetUsbEthernetMacAddressSource, nullptr)));

  const std::optional<net_base::MacAddress> perm_mac =
      manager->device_info()->GetPermAddress(interface_index);
  if (perm_mac.has_value()) {
    permanent_mac_address_ = *perm_mac;
  } else {
    LOG(WARNING) << "Ethernet device with missing perm MAC: " << link_name;
  }

  eap_listener_->set_request_received_callback(base::BindRepeating(
      &Ethernet::OnEapDetected, weak_ptr_factory_.GetWeakPtr()));
  SLOG(this, 2) << "Ethernet device " << link_name << " initialized.";

  if (bus_type_ == kDeviceBusTypeUsb) {
    // Force change MAC address to |permanent_mac_address_| if
    // |mac_address_| != |permanent_mac_address_|.
    SetUsbEthernetMacAddressSource(kUsbEthernetMacAddressSourceUsbAdapterMac,
                                   base::DoNothing());
  }
}

Ethernet::~Ethernet() = default;

void Ethernet::Start(EnabledStateChangedCallback callback) {
  if (IsExternalPciDev(link_name())) {
    if (!DisableOffloadFeatures()) {
      LOG(ERROR) << link_name()
                 << " Interface disabled due to security reasons "
                 << "(failed to disable Offload features)";
      std::move(callback).Run(Error(Error::kPermissionDenied));
      return;
    }
  }

  rtnl_handler()->SetInterfaceFlags(interface_index(), IFF_UP, IFF_UP);
  LOG(INFO) << "Registering " << link_name() << " with manager.";
  if (!service_) {
    service_ = GetProvider()->CreateService(weak_ptr_factory_.GetWeakPtr());
  }
  RegisterService(service_);

  NotifyEthernetDriverName();

  std::move(callback).Run(Error(Error::kSuccess));
}

void Ethernet::Stop(EnabledStateChangedCallback callback) {
  DeregisterService(service_);
  // EthernetProvider::DeregisterService will ResetEthernet() when the Service
  // being deregistered is the only Service remaining (instead of releasing the
  // Service entirely) so that the ethernet_any service continues to live. When
  // this happens, disassociate the EthernetService here as well.
  if (service_ && !service_->HasEthernet()) {
    service_ = nullptr;
  }
  StopSupplicant();

  std::move(callback).Run(Error(Error::kSuccess));
}

void Ethernet::LinkEvent(unsigned int flags, unsigned int change) {
  Device::LinkEvent(flags, change);
  if ((flags & IFF_LOWER_UP) != 0 && !link_up_) {
    link_up_ = true;
    adaptor()->EmitBoolChanged(kLinkUpProperty, link_up_);
    // We SetupWakeOnLan() here, instead of in Start(), because with
    // r8139, "ethtool -s eth0 wol g" fails when no cable is plugged
    // in.
    if (service_) {
      manager()->UpdateService(service_);
      service_->OnVisibilityChanged();
    }
    SetupWakeOnLan();
    eap_listener_->Start();
  } else if ((flags & IFF_LOWER_UP) == 0 && link_up_) {
    link_up_ = false;
    adaptor()->EmitBoolChanged(kLinkUpProperty, link_up_);
    DropConnection();
    if (service_) {
      manager()->UpdateService(service_);
      service_->OnVisibilityChanged();
    }
    is_eap_detected_ = false;
    adaptor()->EmitBoolChanged(kEapAuthenticatorDetectedProperty,
                               is_eap_detected_);
    GetEapProvider()->ClearCredentialChangeCallback(this);
    SetIsEapAuthenticated(false);
    StopSupplicant();
    eap_listener_->Stop();
  }
}

bool Ethernet::Load(const StoreInterface* storage) {
  const std::string id = GetStorageIdentifier();
  if (!storage->ContainsGroup(id)) {
    SLOG(this, 2) << "Device is not available in the persistent store: " << id;
    return false;
  }
  return Device::Load(storage);
}

bool Ethernet::Save(StoreInterface* storage) {
  return Device::Save(storage);
}

void Ethernet::ConnectTo(EthernetService* service) {
  CHECK(service_) << "Service should not be null";
  CHECK(service == service_.get())
      << "Ethernet was asked to connect the wrong service?";
  if (!link_up_) {
    return;
  }
  SelectService(service);
  auto dhcp_opts = manager()->CreateDefaultDHCPOption();
  dhcp_opts.use_arp_gateway = false;
  Network::StartOptions opts = {
      .dhcp = dhcp_opts,
      .accept_ra = true,
      .ignore_link_monitoring = service->link_monitor_disabled(),
      .probing_configuration =
          manager()->GetPortalDetectorProbingConfiguration(),
      .validation_mode = service->GetNetworkValidationMode(),
  };
  GetPrimaryNetwork()->Start(opts);
  SetServiceState(Service::kStateConfiguring);

  // Update link speeds. link speeds are expected to be constant during the L2
  // connection for ethernet.
  UpdateLinkSpeed();
}

std::string Ethernet::DeviceStorageSuffix() const {
  return permanent_mac_address_.has_value()
             ? permanent_mac_address_->ToHexString()
             : Device::DeviceStorageSuffix();
}

void Ethernet::DisconnectFrom(EthernetService* service) {
  CHECK(service_) << "Service should not be null";
  CHECK(service == service_.get())
      << "Ethernet was asked to disconnect the wrong service?";
  DropConnection();
}

EthernetProvider* Ethernet::GetProvider() {
  EthernetProvider* provider = manager()->ethernet_provider();
  CHECK(provider);
  return provider;
}

void Ethernet::TryEapAuthentication() {
  try_eap_authentication_callback_.Reset(base::BindOnce(
      &Ethernet::TryEapAuthenticationTask, weak_ptr_factory_.GetWeakPtr()));
  dispatcher()->PostTask(FROM_HERE,
                         try_eap_authentication_callback_.callback());
}

void Ethernet::BSSAdded(const RpcIdentifier& path,
                        const KeyValueStore& properties) {
  NOTREACHED() << __func__ << " is not implemented for Ethernet";
}

void Ethernet::BSSRemoved(const RpcIdentifier& path) {
  NOTREACHED() << __func__ << " is not implemented for Ethernet";
}

void Ethernet::Certification(const KeyValueStore& properties) {
  std::string subject;
  uint32_t depth;
  if (WPASupplicant::ExtractRemoteCertification(properties, &subject, &depth)) {
    dispatcher()->PostTask(
        FROM_HERE,
        base::BindOnce(&Ethernet::CertificationTask,
                       weak_ptr_factory_.GetWeakPtr(), subject, depth));
  }
}

void Ethernet::EAPEvent(const std::string& status,
                        const std::string& parameter) {
  dispatcher()->PostTask(
      FROM_HERE,
      base::BindOnce(&Ethernet::EAPEventTask, weak_ptr_factory_.GetWeakPtr(),
                     status, parameter));
}

void Ethernet::PropertiesChanged(const KeyValueStore& properties) {
  if (!properties.Contains<std::string>(
          WPASupplicant::kInterfacePropertyState)) {
    return;
  }
  dispatcher()->PostTask(
      FROM_HERE,
      base::BindOnce(
          &Ethernet::SupplicantStateChangedTask, weak_ptr_factory_.GetWeakPtr(),
          properties.Get<std::string>(WPASupplicant::kInterfacePropertyState)));
}

void Ethernet::ScanDone(const bool& /*success*/) {
  NOTREACHED() << __func__ << " is not implemented for Ethernet";
}

void Ethernet::InterworkingAPAdded(const RpcIdentifier& /*BSS*/,
                                   const RpcIdentifier& /*cred*/,
                                   const KeyValueStore& /*properties*/) {
  NOTREACHED() << __func__ << " is not implemented for Ethernet";
}

void Ethernet::InterworkingSelectDone() {
  NOTREACHED() << __func__ << " is not implemented for Ethernet";
}

EthernetEapProvider* Ethernet::GetEapProvider() {
  EthernetEapProvider* eap_provider = manager()->ethernet_eap_provider();
  CHECK(eap_provider);
  return eap_provider;
}

ServiceConstRefPtr Ethernet::GetEapService() {
  ServiceConstRefPtr eap_service = GetEapProvider()->service();
  CHECK(eap_service);
  return eap_service;
}

void Ethernet::OnEapDetected() {
  is_eap_detected_ = true;
  adaptor()->EmitBoolChanged(kEapAuthenticatorDetectedProperty,
                             is_eap_detected_);
  eap_listener_->Stop();
  GetEapProvider()->SetCredentialChangeCallback(
      this, base::BindRepeating(&Ethernet::TryEapAuthentication,
                                weak_ptr_factory_.GetWeakPtr()));
  TryEapAuthentication();
}

bool Ethernet::StartSupplicant() {
  if (supplicant_interface_proxy_) {
    return true;
  }

  RpcIdentifier interface_path;
  KeyValueStore create_interface_args;
  create_interface_args.Set<std::string>(WPASupplicant::kInterfacePropertyName,
                                         link_name());
  create_interface_args.Set<std::string>(
      WPASupplicant::kInterfacePropertyDriver, WPASupplicant::kDriverWired);
  create_interface_args.Set<std::string>(
      WPASupplicant::kInterfacePropertyConfigFile,
      WPASupplicant::kSupplicantConfPath);
  if (!supplicant_process_proxy()->CreateInterface(create_interface_args,
                                                   &interface_path)) {
    // Interface might've already been created, try to retrieve it.
    if (!supplicant_process_proxy()->GetInterface(link_name(),
                                                  &interface_path)) {
      LOG(ERROR) << __func__ << ": Failed to create interface with supplicant.";
      StopSupplicant();
      return false;
    }
  }

  supplicant_interface_proxy_ =
      control_interface()->CreateSupplicantInterfaceProxy(this, interface_path);
  supplicant_interface_path_ = interface_path;
  return true;
}

bool Ethernet::StartEapAuthentication() {
  KeyValueStore params;
  GetEapService()->eap()->PopulateSupplicantProperties(&certificate_file_,
                                                       &params);
  params.Set<std::string>(WPASupplicant::kNetworkPropertyEapKeyManagement,
                          WPASupplicant::kKeyManagementIeee8021X);
  params.Set<uint32_t>(WPASupplicant::kNetworkPropertyEapolFlags, 0);
  params.Set<uint32_t>(WPASupplicant::kNetworkPropertyScanSSID, 0);

  if (service_) {
    service_->ClearEAPCertification();
  }
  eap_state_handler_.Reset();

  if (!supplicant_network_path_.value().empty()) {
    if (!supplicant_interface_proxy_->RemoveNetwork(supplicant_network_path_)) {
      LOG(ERROR) << "Failed to remove network: "
                 << supplicant_network_path_.value();
      return false;
    }
  }
  if (!supplicant_interface_proxy_->AddNetwork(params,
                                               &supplicant_network_path_)) {
    LOG(ERROR) << "Failed to add network";
    return false;
  }
  CHECK(!supplicant_network_path_.value().empty());

  LOG(INFO) << LoggingTag() << ": Triggering EAP authentication";
  supplicant_interface_proxy_->SelectNetwork(supplicant_network_path_);
  supplicant_interface_proxy_->EAPLogon();
  return true;
}

void Ethernet::StopSupplicant() {
  if (supplicant_interface_proxy_) {
    supplicant_interface_proxy_->EAPLogoff();
  }
  supplicant_interface_proxy_.reset();
  if (!supplicant_interface_path_.value().empty()) {
    if (!supplicant_process_proxy()->RemoveInterface(
            supplicant_interface_path_)) {
      LOG(ERROR) << __func__ << ": Failed to remove interface from supplicant.";
    }
  }
  supplicant_network_path_ = RpcIdentifier("");
  supplicant_interface_path_ = RpcIdentifier("");
  SetIsEapAuthenticated(false);
}

void Ethernet::SetIsEapAuthenticated(bool is_eap_authenticated) {
  if (is_eap_authenticated == is_eap_authenticated_) {
    return;
  }

  // If our EAP authentication state changes, we have now joined a different
  // network.  Restart the DHCP process and any other connection state.
  if (service_) {
    DisconnectFrom(service_.get());
    ConnectTo(service_.get());
  }
  is_eap_authenticated_ = is_eap_authenticated;
  adaptor()->EmitBoolChanged(kEapAuthenticationCompletedProperty,
                             is_eap_authenticated_);
}

void Ethernet::CertificationTask(const std::string& subject, uint32_t depth) {
  CHECK(service_) << "Ethernet " << link_name() << " " << __func__
                  << " with no service.";
  service_->AddEAPCertification(subject, depth);
}

void Ethernet::EAPEventTask(const std::string& status,
                            const std::string& parameter) {
  LOG(INFO) << "In " << __func__ << " with status " << status << ", parameter "
            << parameter;
  Service::ConnectFailure failure = Service::kFailureNone;
  if (eap_state_handler_.ParseStatus(status, parameter, &failure)) {
    LOG(INFO) << "EAP authentication succeeded!";
    SetIsEapAuthenticated(true);
  } else if (failure != Service::Service::kFailureNone) {
    LOG(INFO) << "EAP authentication failed!";
    SetIsEapAuthenticated(false);
  }
}

void Ethernet::SupplicantStateChangedTask(const std::string& state) {
  LOG(INFO) << "Supplicant state changed to " << state;
}

void Ethernet::TryEapAuthenticationTask() {
  if (!GetEapService()->Is8021xConnectable()) {
    if (is_eap_authenticated_) {
      LOG(INFO) << "EAP Service lost 802.1X credentials; "
                << "terminating EAP authentication.";
    } else {
      LOG(INFO) << "EAP Service lacks 802.1X credentials; "
                << "not doing EAP authentication.";
    }
    StopSupplicant();
    return;
  }

  if (!is_eap_detected_) {
    LOG(WARNING) << "EAP authenticator not detected; "
                 << "not doing EAP authentication.";
    return;
  }
  if (!StartSupplicant()) {
    LOG(ERROR) << "Failed to start supplicant.";
    return;
  }
  StartEapAuthentication();
}

SupplicantProcessProxyInterface* Ethernet::supplicant_process_proxy() const {
  return manager()->supplicant_manager()->proxy();
}

void Ethernet::SetupWakeOnLan() {
  struct ethtool_wolinfo wake_on_lan_command;
  struct ifreq interface_command;

  memset(&interface_command, 0, sizeof(interface_command));
  memset(&wake_on_lan_command, 0, sizeof(wake_on_lan_command));
  wake_on_lan_command.cmd = ETHTOOL_SWOL;
  if (manager()->IsWakeOnLanEnabled()) {
    wake_on_lan_command.wolopts = WAKE_MAGIC;
  }
  interface_command.ifr_data = &wake_on_lan_command;

  if (!RunEthtoolCmd(&interface_command)) {
    PLOG(WARNING) << "Failed to enable wake-on-lan";
    return;
  }
}

bool Ethernet::DisableOffloadFeatures() {
  struct ifreq interface_command;
  memset(&interface_command, 0, sizeof(interface_command));

  LOG(INFO) << LoggingTag() << ": Disabling offloading features";
  // Prepare and send a ETHTOOL_GSSET_INFO(ETH_SS_FEATURES) command to
  // get number of features.
  struct {
    struct ethtool_sset_info sset_info;
    uint32_t num_features;
  } sset_info_buf;
  memset(&sset_info_buf, 0, sizeof(sset_info_buf));
  struct ethtool_sset_info* sset_info = &sset_info_buf.sset_info;
  sset_info->cmd = ETHTOOL_GSSET_INFO;
  sset_info->reserved = 0;
  sset_info->sset_mask = 1ULL << ETH_SS_FEATURES;
  interface_command.ifr_data = sset_info;
  bool res = RunEthtoolCmd(&interface_command);
  if (!res) {
    PLOG(ERROR) << LoggingTag()
                << ": ETHTOOL_GSSET_INFO(ETH_SS_FEATURES) failed.";
    return false;
  }
  if (!sset_info->sset_mask || !sset_info_buf.num_features) {
    LOG(ERROR) << LoggingTag()
               << ": ETHTOOL_GSSET_INFO(ETH_SS_FEATURES) failed.";
    return false;
  }

  // Get the number of features
  uint32_t num_features = sset_info_buf.num_features;
  uint32_t num_feature_blocks = (num_features + 31) / 32;

  // Now prepare and send ETHTOOL_GSTRINGS(ETH_SS_FEATURES), to actually
  // get the all the feature strings, for this device.
  struct GstringsBuf {
    ethtool_gstrings gstrings;
    char features[MAX_FEATURE_COUNT][ETH_GSTRING_LEN];
  };
  auto gstrings_buf = std::make_unique<GstringsBuf>();
  memset(gstrings_buf.get(), 0, sizeof(GstringsBuf));
  struct ethtool_gstrings* gstrings = &gstrings_buf->gstrings;
  gstrings->cmd = ETHTOOL_GSTRINGS;
  gstrings->string_set = ETH_SS_FEATURES;
  gstrings->len = num_features;
  interface_command.ifr_data = gstrings;
  if (!RunEthtoolCmd(&interface_command)) {
    PLOG(ERROR) << LoggingTag()
                << ": ETHTOOL_GSTRINGS(ETH_SS_FEATURES) failed.";
    return false;
  }

  // Ensure strings are null terminated
  unsigned int i;
  for (i = 0; i < num_features; i++)
    gstrings_buf->features[i][ETH_GSTRING_LEN - 1] = 0;

  // Prepare & send a ETHTOOL_GFEATURES command to get the current state of
  // features
  struct {
    struct ethtool_gfeatures gfeatures;
    ethtool_get_features_block feature_block[MAX_FEATURE_BLOCKS];
  } gfeatures_buf;
  memset(&gfeatures_buf, 0, sizeof(gfeatures_buf));
  struct ethtool_gfeatures* gfeatures = &gfeatures_buf.gfeatures;
  gfeatures->cmd = ETHTOOL_GFEATURES;
  gfeatures->size = num_feature_blocks;
  interface_command.ifr_data = gfeatures;
  if (!RunEthtoolCmd(&interface_command)) {
    PLOG(ERROR) << LoggingTag() << ": ETHTOOL_GFEATURES command failed.";
    return false;
  }

  // Prepare & send a ETHTOOL_SFEATURES command to enable/disable the features
  // features we need
  struct {
    struct ethtool_sfeatures sfeatures;
    ethtool_set_features_block feature_block[MAX_FEATURE_BLOCKS];
  } sfeatures_buf;
  memset(&sfeatures_buf, 0, sizeof(sfeatures_buf));
  struct ethtool_sfeatures* sfeatures = &sfeatures_buf.sfeatures;
  sfeatures->cmd = ETHTOOL_SFEATURES;
  sfeatures->size = num_feature_blocks;

  int ret = true;

  std::set<std::string> features_to_disable(kFeaturesToDisable.begin(),
                                            kFeaturesToDisable.end());

  for (i = 0; i < num_features && !features_to_disable.empty(); i++) {
    std::string feature = gstrings_buf->features[i];
    if (features_to_disable.find(feature) == features_to_disable.end())
      continue;

    features_to_disable.erase(feature);

    uint32_t block_num = i / 32;
    uint32_t feature_mask = 1 << (i % 32);

    if (feature_mask & gfeatures->features[block_num].never_changed) {
      LOG(ERROR) << "[Not Allowed] cannot disable [" << i << "] " << feature;
      ret = false;
      continue;
    }
    if (feature_mask & ~gfeatures->features[block_num].available) {
      LOG(ERROR) << "[Not Available] cannot disable [" << i << "] " << feature;
      // OK to return success since device does not support the feature.
      continue;
    }
    if (!(feature_mask & gfeatures->features[block_num].active)) {
      LOG(INFO) << "[Already Disabled] Not disabling [" << i << "] " << feature;
      // OK to return success since device has it already disabled.
      continue;
    }
    sfeatures->features[block_num].valid |= feature_mask;
    sfeatures->features[block_num].requested &= ~feature_mask;
    LOG(INFO) << LoggingTag() << ": Disabling [" << i << "] " << feature;
  }

  for (const auto& feature : features_to_disable)
    LOG(INFO) << "[No Such Feature] Skipped disabling: " << feature;

  interface_command.ifr_data = sfeatures;
  if (!RunEthtoolCmd(&interface_command)) {
    PLOG(ERROR) << "Failed to disable offloading features.";
    return false;
  }
  LOG(INFO) << LoggingTag() << ": Disabled offloading features successfully";

  return ret;
}

std::string Ethernet::GetUsbEthernetMacAddressSource(Error* error) {
  return usb_ethernet_mac_address_source_;
}

void Ethernet::RegisterService(EthernetServiceRefPtr service) {
  if (!service) {
    return;
  }
  GetProvider()->RegisterService(service);
}

void Ethernet::DeregisterService(EthernetServiceRefPtr service) {
  if (!service) {
    return;
  }
  GetProvider()->DeregisterService(service);
}

void Ethernet::SetUsbEthernetMacAddressSource(const std::string& source,
                                              ResultCallback callback) {
  SLOG(this, 2) << __func__ << " " << source;

  if (bus_type_ != kDeviceBusTypeUsb) {
    Error error;
    Error::PopulateAndLog(FROM_HERE, &error, Error::kIllegalOperation,
                          "Not allowed on non-USB devices: " + bus_type_);
    std::move(callback).Run(error);
    return;
  }

  std::optional<net_base::MacAddress> new_mac_address;
  if (source == kUsbEthernetMacAddressSourceDesignatedDockMac) {
    new_mac_address =
        ReadMacAddressFromFile(base::FilePath(kVpdDockMacFilePath));
  } else if (source == kUsbEthernetMacAddressSourceBuiltinAdapterMac) {
    new_mac_address =
        ReadMacAddressFromFile(base::FilePath(kVpdEthernetMacFilePath));
  } else if (source == kUsbEthernetMacAddressSourceUsbAdapterMac) {
    new_mac_address = permanent_mac_address_;
  } else {
    Error error;
    Error::PopulateAndLog(FROM_HERE, &error, Error::kInvalidArguments,
                          "Unknown source: " + source);
    std::move(callback).Run(error);
    return;
  }

  if (!new_mac_address.has_value()) {
    Error error;
    Error::PopulateAndLog(
        FROM_HERE, &error, Error::kNotFound,
        "Failed to find out new MAC address for source: " + source);
    std::move(callback).Run(error);
    return;
  }

  if (new_mac_address == mac_address()) {
    SLOG(this, 4) << __func__ << " new MAC address is equal to the old one";
    if (usb_ethernet_mac_address_source_ != source) {
      usb_ethernet_mac_address_source_ = source;
      adaptor()->EmitStringChanged(kUsbEthernetMacAddressSourceProperty,
                                   usb_ethernet_mac_address_source_);
    }
    std::move(callback).Run(Error(Error::kSuccess));
    return;
  }

  SLOG(this, 2) << "Send netlink request to change MAC address for "
                << link_name() << " device from "
                << (mac_address().has_value() ? mac_address()->ToString()
                                              : "(null)")
                << " to " << new_mac_address->ToString();

  rtnl_handler()->SetInterfaceMac(
      interface_index(), *new_mac_address,
      base::BindOnce(&Ethernet::OnSetInterfaceMacResponse,
                     weak_ptr_factory_.GetWeakPtr(), source, *new_mac_address,
                     std::move(callback)));
}

std::optional<net_base::MacAddress> Ethernet::ReadMacAddressFromFile(
    const base::FilePath& file_path) {
  std::string mac_address_str;
  if (!base::ReadFileToString(file_path, &mac_address_str)) {
    PLOG(ERROR) << "Unable to read MAC address from file: "
                << file_path.value();
    return std::nullopt;
  }

  const std::optional<net_base::MacAddress> ret =
      net_base::MacAddress::CreateFromString(mac_address_str);
  if (!ret.has_value()) {
    LOG(ERROR) << "Unable to parse MAC address from file: " << file_path.value()
               << ", content: " << mac_address_str;
  }
  return ret;
}

void Ethernet::OnSetInterfaceMacResponse(const std::string& mac_address_source,
                                         net_base::MacAddress new_mac_address,
                                         ResultCallback callback,
                                         int32_t error) {
  if (error) {
    LOG(ERROR) << __func__ << " received response with error "
               << strerror(error);
    if (!callback.is_null()) {
      std::move(callback).Run(Error(Error::kOperationFailed));
    }
    return;
  }

  SLOG(this, 2) << __func__ << " received successful response";

  usb_ethernet_mac_address_source_ = mac_address_source;
  adaptor()->EmitStringChanged(kUsbEthernetMacAddressSourceProperty,
                               usb_ethernet_mac_address_source_);

  set_mac_address(new_mac_address);
  if (!callback.is_null()) {
    std::move(callback).Run(Error(Error::kSuccess));
  }
}

void Ethernet::set_mac_address(net_base::MacAddress new_mac_address) {
  SLOG(this, 2) << __func__ << " " << new_mac_address.ToString();

  ProfileRefPtr profile;
  if (service_) {
    profile = service_->profile();
  }
  // Abandon and adopt service if service storage identifier will change after
  // changing ethernet MAC address.
  if (!permanent_mac_address_.has_value() && profile &&
      !service_->HasStorageIdentifier()) {
    profile->AbandonService(service_);
    Device::set_mac_address(new_mac_address);
    profile->AdoptService(service_);
  } else {
    Device::set_mac_address(new_mac_address);
  }

  if (service_) {
    DisconnectFrom(service_.get());
    ConnectTo(service_.get());
  }
}

std::string Ethernet::GetDeviceBusType() const {
  auto device_id = DeviceId::CreateFromSysfs(base::FilePath(
      base::StringPrintf("/sys/class/net/%s/device", link_name().c_str())));

  constexpr DeviceId kPciDevicePattern{DeviceId::BusType::kPci};
  if (device_id && device_id->Match(kPciDevicePattern)) {
    return kDeviceBusTypePci;
  }
  constexpr DeviceId kUsbDevicePattern{DeviceId::BusType::kUsb};
  if (device_id && device_id->Match(kUsbDevicePattern)) {
    return kDeviceBusTypeUsb;
  }
  return std::string();
}

void Ethernet::UpdateLinkSpeed() {
  if (!selected_service()) {
    return;
  }

  struct ethtool_cmd ecmd;
  struct ifreq ifr;

  memset(&ecmd, 0, sizeof(ecmd));
  memset(&ifr, 0, sizeof(ifr));
  ecmd.cmd = ETHTOOL_GSET;
  ifr.ifr_data = &ecmd;

  if (!RunEthtoolCmd(&ifr)) {
    PLOG(ERROR) << LoggingTag() << " " << __func__
                << " ETHTOOL_GSET command failed ";
    return;
  }
  // Value we get from ecmd is mbps, convert it to kbps to keep
  // with other technologies.
  selected_service()->SetUplinkSpeedKbps(ethtool_cmd_speed(&ecmd) *
                                         kMbpsToKbpsFactor);
  selected_service()->SetDownlinkSpeedKbps(ethtool_cmd_speed(&ecmd) *
                                           kMbpsToKbpsFactor);
}

bool Ethernet::RunEthtoolCmd(ifreq* interface_command) {
  auto socket =
      socket_factory_->Create(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, IPPROTO_IP);
  if (!socket) {
    return false;
  }

  strncpy(interface_command->ifr_name, link_name().c_str(),
          sizeof(interface_command->ifr_name));

  return socket->Ioctl(SIOCETHTOOL, interface_command).has_value();
}

// TODO(b/265607618): Integrate this functionality inside Network or
// NetworkMonitor as a configurable option in Network::StartOptions
void Ethernet::OnNeighborReachabilityEvent(
    int net_interface_index,
    const net_base::IPAddress& ip_address,
    patchpanel::Client::NeighborRole role,
    patchpanel::Client::NeighborStatus status) {
  DCHECK(net_interface_index == interface_index());

  using Role = patchpanel::Client::NeighborRole;
  using Status = patchpanel::Client::NeighborStatus;
  if (role != Role::kGateway && role != Role::kGatewayAndDnsServer) {
    return;
  }

  if (!GetPrimaryNetwork()->IsConnected()) {
    LOG(INFO)
        << LoggingTag()
        << ": Network was disconnected, ignoring neighbor reachability event";
    return;
  }

  // When a reachability failure event is received and the connection is thought
  // to be healthy, make sure that network validation runs to confirm if there
  // is no link connectivity anymore.
  if (status == Status::kFailed &&
      GetPrimaryNetwork()->HasInternetConnectivity()) {
    LOG(INFO)
        << LoggingTag()
        << ": gateway reachability failure in 'Internet-connectivity' state.";
    // Network validation is expected to time out, do not force a restart in
    // case some other mechanism has already triggered a revalidation which
    // would otherwise get cancelled.
    GetPrimaryNetwork()->RequestNetworkValidation(
        NetworkMonitor::ValidationReason::kEthernetGatewayUnreachable);
  }

  // When a reachability success event is received and the connection was
  // thought to be unhealthy, make sure that network validation runs to confirm
  // if link connectivity has been recovered.
  if (status == Status::kReachable &&
      !GetPrimaryNetwork()->HasInternetConnectivity()) {
    LOG(INFO) << LoggingTag()
              << ": gateway reachability event in 'no-connectivity' state.";
    // Validation should be confirmed as soon as possible. If Internet is
    // validation is expected to be short so a restart is always forced.
    GetPrimaryNetwork()->RequestNetworkValidation(
        NetworkMonitor::ValidationReason::kEthernetGatewayReachable);
  }
}

void Ethernet::NotifyEthernetDriverName() {
  struct ethtool_drvinfo drv;
  struct ifreq ifr;
  char dvrname[kDriverNameSize];
  std::string driver;

  memset(&drv, 0, sizeof(drv));
  memset(&ifr, 0, sizeof(ifr));

  drv.cmd = ETHTOOL_GDRVINFO;
  ifr.ifr_data = &drv;

  if (!RunEthtoolCmd(&ifr)) {
    PLOG(ERROR) << LoggingTag() << ": Failed to get ethernet driver name";
    driver = kEthernetDriverNameError;
  } else {
    strncpy(dvrname, drv.driver, sizeof(dvrname));
    // Add a trailing \0 to avoid driver name we got from dvr.driver
    // is not \0 terminated.
    dvrname[kDriverNameSize - 1] = '\0';
    driver = dvrname;
  }

  // Ignore virtual interface drivers used in testing for reporting driver
  // names.
  static constexpr auto ignoredDrivers =
      base::MakeFixedFlatSet<std::string_view>({
          // Name of the /drivers/net/veth.c driver. For interfaces managed by
          // shill, this driver is only used in tast to simulate
          // physical networks.
          "veth",
          // Name of the /drivers/net/virtio_net.c driver. This driver is only
          // used on the
          // host when ChromeOS itself runs on a VM.
          "virtio_net",
      });
  if (ignoredDrivers.find(driver) != ignoredDrivers.end()) {
    return;
  }

  static constexpr auto driverName2enum =
      base::MakeFixedFlatMap<std::string_view, Metrics::EthernetDriver>({
          {"alx", Metrics::kEthernetDriverAlx},
          {"aqc111", Metrics::kEthernetDriverAqc111},
          {"asix", Metrics::kEthernetDriverAsix},
          {"atl1c", Metrics::kEthernetDriverAtl1c},
          {"atlantic", Metrics::kEthernetDriverAtlantic},
          {"ax88179_178a", Metrics::kEthernetDriverAx88179_178a},
          {"cdc_eem", Metrics::kEthernetDriverCdcEem},
          {"cdc_ether", Metrics::kEthernetDriverCdcEther},
          {"cdc_mbim", Metrics::kEthernetDriverCdcMbim},
          {"cdc_ncm", Metrics::kEthernetDriverCdcNcm},
          {"dm9601", Metrics::kEthernetDriverDm9601},
          {"e100", Metrics::kEthernetDriverE100},
          {"e1000", Metrics::kEthernetDriverE1000},
          {"e1000e", Metrics::kEthernetDriverE1000e},
          {"forcedeth", Metrics::kEthernetDriverNForce},
          {"igb", Metrics::kEthernetDriverIgb},
          {"igbvf", Metrics::kEthernetDriverIgbvf},
          {"igc", Metrics::kEthernetDriverIgc},
          {"ipheth", Metrics::kEthernetDriverIpheth},
          {"jme", Metrics::kEthernetDriverJme},
          {"mcs7830", Metrics::kEthernetDriverMcs7830},
          {"MOSCHIP usb-ethernet driver", Metrics::kEthernetDriverMcs7830},
          {"pegasus", Metrics::kEthernetDriverPegasus},
          {"r8152", Metrics::kEthernetDriverR8152},
          {"r8169", Metrics::kEthernetDriverR8169},
          {"rndis_host", Metrics::kEthernetDriverRndisHost},
          {"rtl8150", Metrics::kEthernetDriverRtl8150},
          {"sky2", Metrics::kEthernetDriverSky2},
          {"smsc75xx", Metrics::kEthernetDriverSmsc75xx},
          {"smsc95xx", Metrics::kEthernetDriverSmsc95xx},
          {"st_gmac", Metrics::kEthernetDriverStGmac},
          {"r8153_ecm", Metrics::kEthernetDriverR8153},
          {"tg3", Metrics::kEthernetDriverTg3},
          {"error", Metrics::kEthernetDriverError},
      });

  const auto it = driverName2enum.find(driver);
  if (it == driverName2enum.end()) {
    metrics()->SendEnumToUMA(Metrics::kMetricEthernetDriver,
                             Metrics::kEthernetDriverUnknown);
    LOG(WARNING) << LoggingTag() << ": Unknown ethernet driver name " << '"'
                 << driver << '"';
    return;
  }
  metrics()->SendEnumToUMA(Metrics::kMetricEthernetDriver, it->second);
}

}  // namespace shill