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; }