blob: 318883ec359e30cd5539cd30c1c59e3fd531a50b [file] [log] [blame]
// Copyright 2017 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "device/udev_linux/udev_watcher.h"
#include "base/bind.h"
#include "base/memory/ptr_util.h"
#include "base/threading/scoped_blocking_call.h"
namespace device {
UdevWatcher::Filter::Filter(base::StringPiece subsystem_in,
base::StringPiece devtype_in) {
if (subsystem_in.data())
subsystem_ = subsystem_in.as_string();
if (devtype_in.data())
devtype_ = devtype_in.as_string();
}
UdevWatcher::Filter::Filter(const Filter&) = default;
UdevWatcher::Filter::~Filter() = default;
const char* UdevWatcher::Filter::devtype() const {
return devtype_ ? devtype_.value().c_str() : nullptr;
}
const char* UdevWatcher::Filter::subsystem() const {
return subsystem_ ? subsystem_.value().c_str() : nullptr;
}
UdevWatcher::Observer::~Observer() = default;
std::unique_ptr<UdevWatcher> UdevWatcher::StartWatching(
Observer* observer,
const std::vector<Filter>& filters) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
ScopedUdevPtr udev(udev_new());
if (!udev) {
LOG(ERROR) << "Failed to initialize udev.";
return nullptr;
}
ScopedUdevMonitorPtr udev_monitor(
udev_monitor_new_from_netlink(udev.get(), "udev"));
if (!udev_monitor) {
LOG(ERROR) << "Failed to initialize a udev monitor.";
return nullptr;
}
for (const Filter& filter : filters) {
const int ret = udev_monitor_filter_add_match_subsystem_devtype(
udev_monitor.get(), filter.subsystem(), filter.devtype());
CHECK_EQ(0, ret);
}
if (udev_monitor_enable_receiving(udev_monitor.get()) != 0) {
LOG(ERROR) << "Failed to enable receiving udev events.";
return nullptr;
}
int monitor_fd = udev_monitor_get_fd(udev_monitor.get());
if (monitor_fd < 0) {
LOG(ERROR) << "Udev monitor file descriptor unavailable.";
return nullptr;
}
return base::WrapUnique(new UdevWatcher(
std::move(udev), std::move(udev_monitor), monitor_fd, observer, filters));
}
UdevWatcher::~UdevWatcher() {
DCHECK(sequence_checker_.CalledOnValidSequence());
}
void UdevWatcher::EnumerateExistingDevices() {
DCHECK(sequence_checker_.CalledOnValidSequence());
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
ScopedUdevEnumeratePtr enumerate(udev_enumerate_new(udev_.get()));
if (!enumerate) {
LOG(ERROR) << "Failed to initialize a udev enumerator.";
return;
}
for (const Filter& filter : udev_filters_) {
const int ret =
udev_enumerate_add_match_subsystem(enumerate.get(), filter.subsystem());
CHECK_EQ(0, ret);
}
if (udev_enumerate_scan_devices(enumerate.get()) != 0) {
LOG(ERROR) << "Failed to begin udev enumeration.";
return;
}
udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate.get());
for (udev_list_entry* i = devices; i != nullptr;
i = udev_list_entry_get_next(i)) {
ScopedUdevDevicePtr device(
udev_device_new_from_syspath(udev_.get(), udev_list_entry_get_name(i)));
if (device)
observer_->OnDeviceAdded(std::move(device));
}
}
UdevWatcher::UdevWatcher(ScopedUdevPtr udev,
ScopedUdevMonitorPtr udev_monitor,
int monitor_fd,
Observer* observer,
const std::vector<Filter>& filters)
: udev_(std::move(udev)),
udev_monitor_(std::move(udev_monitor)),
observer_(observer),
udev_filters_(filters) {
file_watcher_ = base::FileDescriptorWatcher::WatchReadable(
monitor_fd,
base::Bind(&UdevWatcher::OnMonitorReadable, base::Unretained(this)));
}
void UdevWatcher::OnMonitorReadable() {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
ScopedUdevDevicePtr device(udev_monitor_receive_device(udev_monitor_.get()));
if (!device)
return;
std::string action(udev_device_get_action(device.get()));
if (action == "add")
observer_->OnDeviceAdded(std::move(device));
else if (action == "remove")
observer_->OnDeviceRemoved(std::move(device));
}
} // namespace device