cairo_drm_device_t *
cairo_drm_device_default (void)
{
struct udev *udev;
struct udev_enumerate *e;
struct udev_list_entry *entry;
cairo_drm_device_t *dev;
/* optimistic atomic pointer read */
dev = _cairo_drm_default_device;
if (dev != NULL)
return dev;
udev = udev_new();
if (udev == NULL) {
_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
return (cairo_drm_device_t *) &_nil_device;
}
e = udev_enumerate_new (udev);
udev_enumerate_add_match_subsystem (e, "drm");
udev_enumerate_scan_devices (e);
udev_list_entry_foreach (entry, udev_enumerate_get_list_entry (e)) {
struct udev_device *device;
device =
udev_device_new_from_syspath (udev,
udev_list_entry_get_name (entry));
dev = cairo_drm_device_get (device);
udev_device_unref (device);
if (dev != NULL) {
if (dev->fd == -1) { /* try again, we may find a usable card */
cairo_drm_device_destroy (dev);
dev = NULL;
} else
break;
}
}
udev_enumerate_unref (e);
udev_unref (udev);
cairo_drm_device_destroy (dev); /* owned by _cairo_drm_default_device */
return dev;
}
void Init()
{
s_devnode_name_map.clear();
// During initialization we use udev to iterate over all /dev/input/event* devices.
// Note: the Linux kernel is currently limited to just 32 event devices. If this ever
// changes, hopefully udev will take care of this.
udev* udev = udev_new();
_assert_msg_(PAD, udev != nullptr, "Couldn't initialize libudev.");
// List all input devices
udev_enumerate* enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "input");
udev_enumerate_scan_devices(enumerate);
udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate);
// Iterate over all input devices
udev_list_entry* dev_list_entry;
udev_list_entry_foreach(dev_list_entry, devices)
{
const char* path = udev_list_entry_get_name(dev_list_entry);
udev_device* dev = udev_device_new_from_syspath(udev, path);
const char* devnode = udev_device_get_devnode(dev);
// We only care about devices which we have read/write access to.
if (devnode && access(devnode, W_OK) == 0)
{
// Unfortunately udev gives us no way to filter out the non event device interfaces.
// So we open it and see if it works with evdev ioctls or not.
std::string name = GetName(devnode);
auto input = std::make_shared<evdevDevice>(devnode);
if (input->IsInteresting())
{
g_controller_interface.AddDevice(std::move(input));
s_devnode_name_map.insert(std::pair<std::string, std::string>(devnode, name));
}
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
StartHotplugThread();
}
bool QUdevService::isSubsystemAvailable(const char *subsystem)
{
bool available = false;
struct udev_enumerate *enumerate = 0;
if (context) {
if ((enumerate = udev_enumerate_new(context))
&& (0 == udev_enumerate_add_match_subsystem(enumerate, subsystem))
&& (0 == udev_enumerate_scan_devices(enumerate))) {
available = (0 != udev_enumerate_get_list_entry(enumerate));
}
}
if (enumerate)
udev_enumerate_unref(enumerate);
return available;
}
/**
* @brief Create a new net object
* @param name The name of the underlying device (eth0, br1, etc)
* @return A newly allocated net object, or NULL on failure
*
* This function creates a new net object based on @p name.
* Only the most minimal lookups are performed at creation in order
* to save memory.
*/
Eeze_Net *
eeze_net_new(const char *name)
{
const char *syspath = NULL;
const char *idx;
_udev_enumerate *en;
_udev_list_entry *devs, *cur;
_udev_device *device = NULL;
Eeze_Net *net;
net = eina_hash_find(eeze_nets, name);
if (net)
{
EINA_REFCOUNT_REF(net);
return net;
}
en = udev_enumerate_new(udev);
udev_enumerate_add_match_sysname(en, name);
udev_enumerate_add_match_subsystem(en, "net");
udev_enumerate_scan_devices(en);
devs = udev_enumerate_get_list_entry(en);
udev_list_entry_foreach(cur, devs)
{
const char *devname, *test;
devname = udev_list_entry_get_name(cur);
test = strrchr(devname, '/');
if (strcmp(++test, name)) continue;
device = _new_device(devname);
syspath = eina_stringshare_add(name);
break;
}
if (!device) return NULL;
net = calloc(1, sizeof(Eeze_Net));
if (!net) return NULL;
EINA_REFCOUNT_INIT(net);
net->device = device;
net->syspath = syspath;
net->name = eina_stringshare_add(name);
idx = udev_device_get_sysattr_value(net->device, "ifindex");
net->index = atoi(idx);
eina_hash_add(eeze_nets, name, net);
udev_enumerate_unref(en);
return net;
}
/** Open the first DRM device matching the criteria */
int drm_open_matching(const char *pci_glob, int flags, int *vendor_id, int *device_id)
{
struct udev *udev;
struct udev_enumerate *e;
struct udev_device *device, *parent;
struct udev_list_entry *entry;
const char *pci_id, *path;
char *tmp;
int fd;
*vendor_id = 0;
*device_id = 0;
udev = udev_new();
if (udev == NULL) {
fprintf(stderr, "failed to initialize udev context\n");
return -1;
//abort();
}
fd = -1;
e = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(e, "drm");
udev_enumerate_scan_devices(e);
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(udev, path);
parent = udev_device_get_parent(device);
/* Filter out KMS output devices. */
if (strcmp(udev_device_get_subsystem(parent), "pci") != 0)
continue;
pci_id = udev_device_get_property_value(parent, "PCI_ID");
if (fnmatch(pci_glob, pci_id, 0) != 0)
continue;
fd = open(udev_device_get_devnode(device), O_RDWR);
if (fd < 0)
continue;
if ((flags & DRM_TEST_MASTER) && !is_master(fd)) {
close(fd);
fd = -1;
continue;
}
break;
}
int linux_udev_scan_devices(struct libusb_context *ctx)
{
struct udev_enumerate *enumerator;
struct udev_list_entry *devices, *entry;
struct udev_device *udev_dev;
const char *sys_name;
int r;
if (NULL == udev_ctx) {
udev_ctx = udev_new();
if (!udev_ctx) {
return LIBUSB_ERROR_OTHER;
}
}
enumerator = udev_enumerate_new(udev_ctx);
if (NULL == enumerator) {
usbi_err(ctx, "error creating udev enumerator");
return LIBUSB_ERROR_OTHER;
}
udev_enumerate_add_match_subsystem(enumerator, "usb");
udev_enumerate_scan_devices(enumerator);
devices = udev_enumerate_get_list_entry(enumerator);
udev_list_entry_foreach(entry, devices) {
const char *path = udev_list_entry_get_name(entry);
uint8_t busnum = 0, devaddr = 0;
udev_dev = udev_device_new_from_syspath(udev_ctx, path);
r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);
if (r) {
udev_device_unref(udev_dev);
continue;
}
linux_enumerate_device(ctx, busnum, devaddr, sys_name);
udev_device_unref(udev_dev);
}
udev_enumerate_unref(enumerator);
return LIBUSB_SUCCESS;
}
int manager_udev_enumerate_links(Manager *m) {
struct udev_list_entry *item = NULL, *first = NULL;
struct udev_enumerate *e;
int r;
assert(m);
e = udev_enumerate_new(m->udev);
if (!e) {
r = -ENOMEM;
goto finish;
}
r = udev_enumerate_add_match_subsystem(e, "net");
if (r < 0)
goto finish;
r = udev_enumerate_scan_devices(e);
if (r < 0)
goto finish;
first = udev_enumerate_get_list_entry(e);
udev_list_entry_foreach(item, first) {
struct udev_device *d;
int k;
d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
if (!d) {
r = -ENOMEM;
goto finish;
}
k = manager_process_link(m, d);
udev_device_unref(d);
if (k < 0)
r = k;
}
finish:
if (e)
udev_enumerate_unref(e);
return r;
}
eErrorCode GetStorageDevicePaths(std::vector<String>& DevicePaths, std::vector<String>& SysDevicePaths)
{
struct udev *udevObject;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *udevListEntry;
struct udev_device *udevDevice;
//! Create the udev object
udevObject = udev_new();
if (nullptr == udevObject)
{
//! ERROR: Can't create udev
return(eErrorCode::Memory);
}
//! Create a list of the devices in the 'block' subsystem
enumerate = udev_enumerate_new(udevObject);
udev_enumerate_add_match_subsystem(enumerate, "block");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(udevListEntry, devices)
{
const char *devicePath;
devicePath = udev_list_entry_get_name(udevListEntry);
udevDevice = udev_device_new_from_syspath(udevObject, devicePath);
String udeviceNode = udev_device_get_devnode(udevDevice);
if (true == IsStorageDisk(udevDevice))
{
DevicePaths.push_back(udeviceNode);
SysDevicePaths.push_back(devicePath);
}
udev_device_unref(udevDevice);
}
//! Free the enumerator object
udev_enumerate_unref(enumerate);
udev_unref(udevObject);
return(eErrorCode::None);
}
Array<GamepadDeviceInfo> LinuxGetAttachedJoysticks() {
Array<GamepadDeviceInfo> deviceInfoArray;
udev *udev_context;
udev_enumerate *enumerate;
udev_list_entry *devices, *dev_list_entry;
udev_device *dev;
udev_context = udev_new();
if (!udev_context) {
// TODO: Throw error
return deviceInfoArray;
}
enumerate = udev_enumerate_new(udev_context);
udev_enumerate_add_match_subsystem(enumerate, "input");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path = NULL, *devnode = NULL;
path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev_context, path);
devnode = udev_device_get_devnode(dev);
dev = udev_device_get_parent_with_subsystem_devtype(
dev, "usb", "usb_device");
if (devnode && dev) {
if (strstr(devnode, "js")) {
GamepadDeviceInfo deviceInfo;
deviceInfo.mProductName =
udev_device_get_sysattr_value(dev, "product");
deviceInfo.mManufacturer =
udev_device_get_sysattr_value(dev, "manufacturer");
deviceInfo.mGuid =
String(udev_device_get_sysattr_value(dev, "product")) +
String(udev_device_get_sysattr_value(dev, "idVendor")) +
String(udev_device_get_sysattr_value(dev, "serial"));
deviceInfo.mDeviceHandle =
open(devnode, O_RDONLY | O_NONBLOCK);
deviceInfoArray.Append(deviceInfo);
}
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
udev_unref(udev_context);
return deviceInfoArray;
}
char *v4l2cpi_udev_get_serial (const char* devfile)
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
char *ret = NULL;
udev = udev_new ();
if (!udev)
return NULL;
enumerate = udev_enumerate_new (udev);
udev_enumerate_add_match_subsystem (enumerate, "video4linux");
udev_enumerate_scan_devices (enumerate);
devices = udev_enumerate_get_list_entry (enumerate);
udev_list_entry_foreach (dev_list_entry, devices){
const char *path;
path = udev_list_entry_get_name (dev_list_entry);
dev = udev_device_new_from_syspath (udev, path);
if (!strcmp (udev_device_get_devnode (dev), devfile)){
dev = udev_device_get_parent_with_subsystem_devtype (dev, "usb", "usb_device");
if (dev){
const char *serial;
serial = udev_device_get_sysattr_value(dev, "serial");
if (serial){
ret = malloc (strlen (serial)+1);
strcpy (ret, serial);
}
udev_device_unref (dev);
}
}
}
/* Free the enumerator object */
udev_enumerate_unref(enumerate);
udev_unref(udev);
return ret;
}
// List of devices: http://www.ideasonboard.org/uvc/
// How to use libudev: http://www.signal11.us/oss/udev/
std::vector<LinuxCaptureDevice> VideoCaptureV4L2::getDeviceList() {
std::vector<LinuxCaptureDevice> found_devices;
struct udev* udev;
struct udev_enumerate* enumerate;
struct udev_list_entry* devices;
struct udev_list_entry* dev_list_entry;
struct udev_device* dev;
udev = udev_new();
if(!udev) {
printf("ERROR: cannot udev_new()\n");
return found_devices;
}
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "video4linux");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
LinuxCaptureDevice linux_device;
const char* path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, path);
const char* devpath = udev_device_get_devnode(dev);
linux_device.path.assign(devpath, strlen(devpath));
dev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device");
if(!dev) {
printf("VERBOSE: cannot find related usb device.\n");
found_devices.push_back(linux_device);
continue;
}
const char* id_vendor = udev_device_get_sysattr_value(dev, "idVendor");
linux_device.id_vendor.assign(id_vendor, strlen(id_vendor));
const char* id_product = udev_device_get_sysattr_value(dev, "idProduct");
linux_device.id_product.assign(id_product, strlen(id_product));
found_devices.push_back(linux_device);
}
void DeviceManager::initHotplug()
{
udev * uDev;
udev_enumerate * uDevEnum;
udev_list_entry * uDevList;
udev_list_entry * uDevListEntry;
udev_device * device;
uDev = udev_new();
if (!uDev)
{
LOG("[DeviceManager] Could not initialize udev! HID passthrough will be disabled.\n");
return;
}
hotplugMonitor = udev_monitor_new_from_netlink(uDev, "udev");
udev_monitor_filter_add_match_subsystem_devtype(hotplugMonitor, "hidraw", nullptr);
udev_monitor_enable_receiving(hotplugMonitor);
fdHotplug = udev_monitor_get_fd(hotplugMonitor);
uDevEnum = udev_enumerate_new(uDev);
udev_enumerate_add_match_subsystem(uDevEnum, "hidraw");
udev_enumerate_scan_devices(uDevEnum);
uDevList = udev_enumerate_get_list_entry(uDevEnum);
udev_list_entry_foreach(uDevListEntry, uDevList)
{
const char * devicePath;
devicePath = udev_list_entry_get_name(uDevListEntry);
device = udev_device_new_from_syspath(uDev, devicePath);
add(new DeviceHard(udev_device_get_devnode(device)));
udev_device_unref(device);
}
udev_enumerate_unref(uDevEnum);
}
int
main(int argc, char **argv)
{
int blight, connector_id;
const char *default_seat = "seat0";
const char *path, *device_seat;
struct udev *udev;
struct udev_enumerate *e;
struct udev_list_entry *entry;
struct udev_device *device, *drm_device;
if (argc < 3) {
printf("Please add connector_id and brightness values from 0-255\n");
return 1;
}
connector_id = atoi(argv[1]);
blight = atoi(argv[2]);
udev = udev_new();
if (udev == NULL) {
printf("failed to initialize udev context\n");
return 1;
}
e = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(e, "drm");
udev_enumerate_add_match_sysname(e, "card[0-9]*");
udev_enumerate_scan_devices(e);
drm_device = NULL;
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
path = udev_list_entry_get_name(entry);
device = udev_device_new_from_syspath(udev, path);
device_seat =
udev_device_get_property_value(device, "ID_SEAT");
if (!device_seat)
device_seat = default_seat;
drm_device = device;
break;
}
int manager_udev_enumerate_links(Manager *m) {
_cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
struct udev_list_entry *item = NULL, *first = NULL;
int r;
assert(m);
e = udev_enumerate_new(m->udev);
if (!e)
return -ENOMEM;
r = udev_enumerate_add_match_subsystem(e, "net");
if (r < 0)
return r;
/* udev does not initialize devices inside containers,
* so we rely on them being already initialized before
* entering the container */
if (detect_container(NULL) <= 0) {
r = udev_enumerate_add_match_is_initialized(e);
if (r < 0)
return r;
}
r = udev_enumerate_scan_devices(e);
if (r < 0)
return r;
first = udev_enumerate_get_list_entry(e);
udev_list_entry_foreach(item, first) {
_cleanup_udev_device_unref_ struct udev_device *d = NULL;
int k;
d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
if (!d)
return -ENOMEM;
k = manager_process_link(m, d);
if (k < 0)
r = k;
}
void gpio_switch_list_for_each(gpio_switch_list_callback callback, void *arg)
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *dl;
struct udev_list_entry *dev_list_entry;
if (!callback)
return;
udev = udev_new();
assert(udev != NULL);
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "input");
udev_enumerate_scan_devices(enumerate);
dl = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, dl) {
const char *path = udev_list_entry_get_name(dev_list_entry);
struct udev_device *dev = udev_device_new_from_syspath(udev,
path);
const char *devnode = udev_device_get_devnode(dev);
char *ioctl_name;
if (devnode == NULL)
continue;
ioctl_name = sys_input_get_device_name(devnode);
if (ioctl_name == NULL)
continue;
if (callback(devnode, ioctl_name, arg)) {
free(ioctl_name);
break;
}
free(ioctl_name);
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
}
void MImHwKeyboardTrackerPrivate::detectEvdev()
{
// Use udev to enumerate all input devices, using evdev on each device to
// find the first device offering a SW_TABLET_MODE switch. If found, this
// switch is used to determine keyboard presence.
struct udev_list_entry *device;
struct udev_list_entry *devices;
struct udev *udev = udev_new();
if (!udev)
return;
struct udev_enumerate *enumerate = udev_enumerate_new(udev);
if (!enumerate) {
udev_unref(udev);
return;
}
udev_enumerate_add_match_subsystem(enumerate, "input");
udev_enumerate_add_match_property(enumerate, "ID_INPUT", "1");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(device, devices) {
const char *syspath = udev_list_entry_get_name(device);
struct udev_device *udev_device =
udev_device_new_from_syspath(udev, syspath);
const char *device = udev_device_get_devnode(udev_device);
if (device)
tryEvdevDevice(device);
udev_device_unref(udev_device);
if (present)
break;
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
}
int
rw_netlink_get_pci_addr(const char *ifname, rw_pci_address_t *pci_addr)
{
struct udev *udev = NULL;
struct udev_enumerate *enumerate = NULL;
struct udev_list_entry *devices, *dev_list_entry;
int ret = -1;
udev = udev_new();
if (!udev) {
ret = -1;
goto ret;
}
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "net");
udev_enumerate_add_match_sysname(enumerate, ifname);
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path;
path = udev_list_entry_get_name(dev_list_entry);
ret = rw_sys_populate_pci_from_path(path, pci_addr);
if (!ret){
break;
}
}
ret:
if (enumerate){
udev_enumerate_unref(enumerate);
}
if (udev){
udev_unref(udev);
}
return ret;
}
static void udev_enum(){
struct udev_enumerate* enumerator = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerator, "usb");
udev_enumerate_add_match_sysattr(enumerator, "idVendor", V_CORSAIR_STR);
udev_enumerate_scan_devices(enumerator);
struct udev_list_entry* devices, *dev_list_entry;
devices = udev_enumerate_get_list_entry(enumerator);
udev_list_entry_foreach(dev_list_entry, devices){
const char* path = udev_list_entry_get_name(dev_list_entry);
if(!path)
continue;
struct udev_device* dev = udev_device_new_from_syspath(udev, path);
if(!dev)
continue;
// If the device matches a recognized device ID, open it
if(usb_add_device(dev))
// Release device if not
udev_device_unref(dev);
}
udev_enumerate_unref(enumerator);
}
struct icd_drm_device *icd_drm_enumerate(const struct icd_instance *instance,
int vendor_id)
{
struct icd_drm_device *devices = NULL;
struct udev *udev;
struct udev_enumerate *e;
struct udev_list_entry *entry;
udev = udev_new();
if (udev == NULL) {
icd_instance_log(instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
0, VK_NULL_HANDLE, /* obj_type, object */
0, 0, /* location, msg_code */
"failed to initialize udev context");
return NULL;
}
e = udev_enumerate_new(udev);
if (e == NULL) {
icd_instance_log(instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,
0, VK_NULL_HANDLE, /* obj_type, object */
0, 0, /* location, msg_code */
"failed to initialize udev enumerate context");
udev_unref(udev);
return NULL;
}
/* we are interested in DRM minors */
udev_enumerate_add_match_subsystem(e, "drm");
udev_enumerate_add_match_property(e, "DEVTYPE", "drm_minor");
udev_enumerate_scan_devices(e);
udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {
devices = probe_syspath(instance, devices, udev,
udev_list_entry_get_name(entry), vendor_id);
}
static char *get_leds_syspath_prefix(struct udev_device *udevice)
{
struct udev_list_entry *dev_list_entry;
struct udev_enumerate *enumerate;
struct udev_device *hid_parent;
const char *syspath;
char *syspath_prefix;
hid_parent = udev_device_get_parent_with_subsystem_devtype(udevice,
"hid", NULL);
enumerate = udev_enumerate_new(udev_device_get_udev(udevice));
udev_enumerate_add_match_parent(enumerate, hid_parent);
udev_enumerate_add_match_subsystem(enumerate, "leds");
udev_enumerate_scan_devices(enumerate);
dev_list_entry = udev_enumerate_get_list_entry(enumerate);
if (!dev_list_entry) {
syspath_prefix = NULL;
goto out;
}
syspath = udev_list_entry_get_name(dev_list_entry);
/*
* All the sysfs paths of the LEDs have the same structure, just the
* number changes, so strip it and store only the common prefix.
*
* Subtracting 1 here means assuming that the LED number is a single
* digit, this is safe as the kernel driver only exposes 4 LEDs.
*/
syspath_prefix = strndup(syspath, strlen(syspath) - 1);
out:
udev_enumerate_unref(enumerate);
return syspath_prefix;
}
udevGetDevices(struct udev *udev, virUdevStatus status)
{
struct udev_enumerate *enumerate;
/* Create a new enumeration to create a list */
enumerate = udev_enumerate_new(udev);
if (!enumerate)
return NULL;
/* Enumerate all network subsystem devices */
udev_enumerate_add_match_subsystem(enumerate, "net");
/* Ignore devices that are part of a bridge */
udev_enumerate_add_nomatch_sysattr(enumerate, "brport/state", NULL);
/* State of the device */
switch (status) {
case VIR_UDEV_IFACE_ACTIVE:
udev_enumerate_add_match_sysattr(enumerate, "operstate", "up");
break;
case VIR_UDEV_IFACE_INACTIVE:
udev_enumerate_add_match_sysattr(enumerate, "operstate", "down");
break;
case VIR_UDEV_IFACE_ALL:
break;
}
/* We don't want to see the TUN devices that QEMU creates for other guests
* running on this machine. By saying nomatch NULL, we just are getting
* devices without the tun_flags sysattr.
*/
udev_enumerate_add_nomatch_sysattr(enumerate, "tun_flags", NULL);
return enumerate;
}
void udev_init(bool autoload, char* mapfile) {
udev = udev_new();
if (!udev) {
fprintf(stderr, "Can't create udev\n");
exit(1);
}
autoadd = autoload;
if (autoload) {
struct udev_enumerate *enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "input");
udev_enumerate_scan_devices(enumerate);
struct udev_list_entry *devices = udev_enumerate_get_list_entry(enumerate);
struct udev_list_entry *dev_list_entry;
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path = udev_list_entry_get_name(dev_list_entry);
struct udev_device *dev = udev_device_new_from_syspath(udev, path);
const char *devnode = udev_device_get_devnode(dev);
int id;
if (devnode != NULL && sscanf(devnode, "/dev/input/event%d", &id) == 1) {
evdev_create(devnode, mapfile);
}
udev_device_unref(dev);
}
udev_enumerate_unref(enumerate);
}
udev_mon = udev_monitor_new_from_netlink(udev, "udev");
udev_monitor_filter_add_match_subsystem_devtype(udev_mon, "input", NULL);
udev_monitor_enable_receiving(udev_mon);
defaultMapfile = mapfile;
int udev_fd = udev_monitor_get_fd(udev_mon);
loop_add_fd(udev_fd, &udev_handle, POLLIN);
}
void
mount_plugged_devices (struct udev *udev)
{
const char *path;
const char *dev_node;
struct udev_enumerate *udev_enum;
struct udev_list_entry *devices;
struct udev_list_entry *entry;
struct udev_device *dev;
udev_enum = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(udev_enum, "block");
udev_enumerate_scan_devices(udev_enum);
devices = udev_enumerate_get_list_entry(udev_enum);
udev_list_entry_foreach(entry, devices) {
path = udev_list_entry_get_name(entry);
dev = udev_device_new_from_syspath(udev, path);
dev_node = udev_device_get_devnode(dev);
if (!device_is_mounted((char *)dev_node))
device_mount(dev);
}
void TeensyControls_find_new_usb_devices(void)
{
fd_set fds;
struct timeval tv;
struct udev_device *dev;
const char *name, *action;
static unsigned int count=0, first=1;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
const char *path;
int r;
if (first) {
// set up monitoring
printf("TeensyControls_usb_init: set up udev monitoring\n");
mon = udev_monitor_new_from_netlink(udev, "udev");
udev_monitor_filter_add_match_subsystem_devtype(mon, "hidraw", NULL);
udev_monitor_enable_receiving(mon);
monfd = udev_monitor_get_fd(mon);
// enumerate all currently attached devices
printf("TeensyControls_usb_init: udev enumerate devices\n");
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "hidraw");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
path = udev_list_entry_get_name(dev_list_entry);
//printf("path: %s\n", path);
dev = udev_device_new_from_syspath(udev, path);
if (dev) {
new_usb_device(dev);
udev_device_unref(dev);
}
}
udev_enumerate_unref(enumerate);
first = 0;
}
static int
get_usbinfo(int bus, int dev, usbinfo_t *ui)
{
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *udev_dev;
char bus_str[16], dev_str[16];
int vendor, product;
enumerate = udev_enumerate_new(udev_handle);
if (!enumerate) {
xd_log(LOG_ERR, "Can't create enumeration");
return -ENOMEM;
}
snprintf(bus_str, sizeof(bus_str), "%d", bus);
snprintf(dev_str, sizeof(dev_str), "%d", dev);
udev_enumerate_add_match_subsystem(enumerate, "usb");
udev_enumerate_add_match_sysattr(enumerate, "busnum", bus_str);
udev_enumerate_add_match_sysattr(enumerate, "devnum", dev_str);
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path;
path = udev_list_entry_get_name(dev_list_entry);
udev_dev = udev_device_new_from_syspath(udev_handle, path);
sscanf(udev_device_get_sysattr_value(udev_dev, "idVendor"), "%x", &vendor);
sscanf(udev_device_get_sysattr_value(udev_dev, "idProduct"), "%x", &product);
udev_device_unref(udev_dev);
udev_enumerate_unref(enumerate);
return usbowls_build_usbinfo(bus, dev, vendor, product, ui);
}
udev_enumerate_unref(enumerate);
return -ENOENT;
}
static int smart_read (void)
{
struct udev *handle_udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
/* Use udev to get a list of disks */
handle_udev = udev_new();
if (!handle_udev)
{
ERROR ("smart plugin: unable to initialize udev.");
return (-1);
}
INFO ("smart plugin: udev initialized.");
enumerate = udev_enumerate_new (handle_udev);
udev_enumerate_add_match_subsystem (enumerate, "block");
udev_enumerate_add_match_property (enumerate, "DEVTYPE", "disk");
udev_enumerate_scan_devices (enumerate);
devices = udev_enumerate_get_list_entry (enumerate);
udev_list_entry_foreach (dev_list_entry, devices)
{
const char *path, *devpath;
path = udev_list_entry_get_name (dev_list_entry);
dev = udev_device_new_from_syspath (handle_udev, path);
devpath = udev_device_get_devnode (dev);
/* Query status with libatasmart */
smart_handle_disk (devpath);
}
udev_enumerate_unref (enumerate);
udev_unref (handle_udev);
return (0);
} /* int smart_read */
static void scan_devices(context_t *ctx)
{
struct udev *udev;
struct udev_enumerate *enm;
struct udev_list_entry *list, *entry;
struct udev_device *dev;
const char *syspath;
if (!ctx || !(udev = ctx->udev))
return;
enm = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enm, "input");
udev_enumerate_scan_devices(enm);
list = udev_enumerate_get_list_entry(enm);
udev_list_entry_foreach(entry, list) {
syspath = udev_list_entry_get_name(entry);
if ((dev = udev_device_new_from_syspath(udev, syspath))) {
handle_device(ctx, dev);
udev_device_unref(dev);
}
}
static void manager_read_links(struct manager *m)
{
_cleanup_udev_enumerate_ struct udev_enumerate *e = NULL;
struct udev_list_entry *l;
struct udev_device *d;
int r;
e = udev_enumerate_new(m->udev);
if (!e)
goto error;
r = udev_enumerate_add_match_subsystem(e, "net");
if (r < 0)
goto error;
r = udev_enumerate_add_match_property(e, "DEVTYPE", "wlan");
if (r < 0)
goto error;
r = udev_enumerate_add_match_is_initialized(e);
if (r < 0)
goto error;
r = udev_enumerate_scan_devices(e);
if (r < 0)
goto error;
udev_list_entry_foreach(l, udev_enumerate_get_list_entry(e)) {
d = udev_device_new_from_syspath(m->udev,
udev_list_entry_get_name(l));
if (!d)
goto error;
manager_add_udev_link(m, d);
udev_device_unref(d);
}
int manager_udev_enumerate_links(Manager *m) {
_cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;
struct udev_list_entry *item = NULL, *first = NULL;
int r;
assert(m);
e = udev_enumerate_new(m->udev);
if (!e)
return -ENOMEM;
r = udev_enumerate_add_match_subsystem(e, "net");
if (r < 0)
return r;
r = udev_enumerate_add_match_is_initialized(e);
if (r < 0)
return r;
r = udev_enumerate_scan_devices(e);
if (r < 0)
return r;
first = udev_enumerate_get_list_entry(e);
udev_list_entry_foreach(item, first) {
_cleanup_udev_device_unref_ struct udev_device *d = NULL;
int k;
d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));
if (!d)
return -ENOMEM;
k = manager_process_link(m, d);
if (k < 0)
r = k;
}
struct hid_device_info HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id)
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct hid_device_info *root = NULL; // return object
struct hid_device_info *cur_dev = NULL;
setlocale(LC_ALL,"");
/* Create the udev object */
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
return NULL;
}
/* Create a list of the devices in the 'hidraw' subsystem. */
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "hidraw");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
/* For each item, see if it matches the vid/pid, and if so
create a udev_device record for it */
udev_list_entry_foreach(dev_list_entry, devices) {
const char *sysfs_path;
const char *dev_path;
const char *str;
struct udev_device *hid_dev; // The device's HID udev node.
struct udev_device *dev; // The actual hardware device.
struct udev_device *intf_dev; // The device's interface (in the USB sense).
unsigned short dev_vid;
unsigned short dev_pid;
/* Get the filename of the /sys entry for the device
and create a udev_device object (dev) representing it */
sysfs_path = udev_list_entry_get_name(dev_list_entry);
hid_dev = udev_device_new_from_syspath(udev, sysfs_path);
dev_path = udev_device_get_devnode(hid_dev);
/* The device pointed to by hid_dev contains information about
the hidraw device. In order to get information about the
USB device, get the parent device with the
subsystem/devtype pair of "usb"/"usb_device". This will
be several levels up the tree, but the function will find
it.*/
dev = udev_device_get_parent_with_subsystem_devtype(
hid_dev,
"usb",
"usb_device");
if (!dev) {
/* Unable to find parent usb device. */
goto next;
}
/* Get the VID/PID of the device */
str = udev_device_get_sysattr_value(dev,"idVendor");
dev_vid = (str)? strtol(str, NULL, 16): 0x0;
str = udev_device_get_sysattr_value(dev, "idProduct");
dev_pid = (str)? strtol(str, NULL, 16): 0x0;
/* Check the VID/PID against the arguments */
if ((vendor_id == 0x0 && product_id == 0x0) ||
(vendor_id == dev_vid && product_id == dev_pid)) {
struct hid_device_info *tmp;
size_t len;
/* VID/PID match. Create the record. */
tmp = malloc(sizeof(struct hid_device_info));
if (cur_dev) {
cur_dev->next = tmp;
}
else {
root = tmp;
}
cur_dev = tmp;
/* Fill out the record */
cur_dev->next = NULL;
str = dev_path;
if (str) {
len = strlen(str);
cur_dev->path = calloc(len+1, sizeof(char));
strncpy(cur_dev->path, str, len+1);
cur_dev->path[len] = '\0';
}
else
cur_dev->path = NULL;
/* Serial Number */
cur_dev->serial_number
= copy_udev_string(dev, "serial");
/* Manufacturer and Product strings */
cur_dev->manufacturer_string
= copy_udev_string(dev, "manufacturer");
cur_dev->product_string
= copy_udev_string(dev, "product");
/* VID/PID */
cur_dev->vendor_id = dev_vid;
cur_dev->product_id = dev_pid;
/* Release Number */
str = udev_device_get_sysattr_value(dev, "bcdDevice");
cur_dev->release_number = (str)? strtol(str, NULL, 16): 0x0;
/* Interface Number */
cur_dev->interface_number = -1;
/* Get a handle to the interface's udev node. */
intf_dev = udev_device_get_parent_with_subsystem_devtype(
hid_dev,
"usb",
"usb_interface");
if (intf_dev) {
str = udev_device_get_sysattr_value(intf_dev, "bInterfaceNumber");
cur_dev->interface_number = (str)? strtol(str, NULL, 16): -1;
}
}
else
goto next;
next:
udev_device_unref(hid_dev);
/* dev and intf_dev don't need to be (and can't be)
unref()d. It will cause a double-free() error. I'm not
sure why. */
}
/* Free the enumerator and udev objects. */
udev_enumerate_unref(enumerate);
udev_unref(udev);
return root;
}
