void UdevSubsystem::enumerate_udev_devices() { assert(m_process_match_cb); // Enumerate over all devices already connected to the computer struct udev_enumerate* enumerate = udev_enumerate_new(m_udev); assert(enumerate); udev_enumerate_add_match_subsystem(enumerate, "usb"); // not available yet: udev_enumerate_add_match_is_initialized(enumerate); udev_enumerate_scan_devices(enumerate); struct udev_list_entry* devices; struct udev_list_entry* dev_list_entry; devices = udev_enumerate_get_list_entry(enumerate); udev_list_entry_foreach(dev_list_entry, devices) { // name is path, value is NULL const char* path = udev_list_entry_get_name(dev_list_entry); struct udev_device* device = udev_device_new_from_syspath(m_udev, path); // manually filter for devtype, as udev enumerate can't do it by itself const char* devtype = udev_device_get_devtype(device); if (devtype && strcmp(devtype, "usb_device") == 0) { m_process_match_cb(device); } udev_device_unref(device); } udev_enumerate_unref(enumerate); }
void joystick_linux::enumerate_joysticks(udev *p_udev) { udev_enumerate *enumerate; udev_list_entry *devices, *dev_list_entry; udev_device *dev; enumerate = udev_enumerate_new(p_udev); udev_enumerate_add_match_subsystem(enumerate,"input"); udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1"); udev_enumerate_scan_devices(enumerate); devices = udev_enumerate_get_list_entry(enumerate); udev_list_entry_foreach(dev_list_entry, devices) { const char* path = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(p_udev, path); const char* devnode = udev_device_get_devnode(dev); if (devnode) { String devnode_str = devnode; if (devnode_str.find(ignore_str) == -1) { joy_mutex->lock(); open_joystick(devnode); joy_mutex->unlock(); } } udev_device_unref(dev); } udev_enumerate_unref(enumerate); }
int get_device_count() { struct udev *udev = udev_new(); if (!udev) { return -1; } struct udev_enumerate *enumerate; struct udev_list_entry *devices, *dev_list_entry; struct udev_device *dev; enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(enumerate, "usb"); udev_enumerate_scan_devices(enumerate); devices = udev_enumerate_get_list_entry(enumerate); const char *path; int count = 0; udev_list_entry_foreach(dev_list_entry, devices) { path = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(udev, path); if(!dev) return -1; const char * vid = udev_device_get_sysattr_value(dev,"idVendor"); const char * pid = udev_device_get_sysattr_value(dev,"idProduct"); if((vid && pid) && (!strcmp(vid, "04d8") && (!strcmp(pid, "e11c")))) count++; udev_device_unref(dev); }
int wgbm_get_default_fd_for_pattern(const char *pattern) { struct udev *ud; struct udev_enumerate *en; struct udev_list_entry *devices, *entry; const char *path, *filename; struct udev_device *device; int fd; ud = udev_new(); en = udev_enumerate_new(ud); udev_enumerate_add_match_subsystem(en, "drm"); udev_enumerate_add_match_sysname(en, pattern); udev_enumerate_scan_devices(en); devices = udev_enumerate_get_list_entry(en); udev_list_entry_foreach(entry, devices) { path = udev_list_entry_get_name(entry); device = udev_device_new_from_syspath(ud, path); filename = udev_device_get_devnode(device); fd = open(filename, O_RDWR | O_CLOEXEC); udev_device_unref(device); if (fd >= 0) { udev_enumerate_unref(en); udev_unref(ud); return fd; } }
static int udev_input_add_devices(struct udev_input *input, struct udev *udev) { struct udev_enumerate *e; struct udev_list_entry *entry; struct udev_device *device; const char *path, *sysname; struct udev_seat *seat; int devices_found = 0; e = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(e, "input"); 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); sysname = udev_device_get_sysname(device); if (strncmp("event", sysname, 5) != 0) { udev_device_unref(device); continue; } if (device_added(device, input) < 0) { udev_device_unref(device); udev_enumerate_unref(e); return -1; } udev_device_unref(device); }
int scan_connected_devices(detector_state_t *state) { struct udev_list_entry *cursor; struct udev_enumerate *ue; struct udev_device *ud; const char *devnode = NULL; if( !(ue = udev_enumerate_new(state->u)) ) return 1; udev_enumerate_add_match_subsystem(ue, "tty"); udev_enumerate_add_match_property(ue, "ID_BUS", "usb"); udev_enumerate_scan_devices(ue); cursor = udev_enumerate_get_list_entry(ue); do { ud = udev_device_new_from_syspath( state->u, udev_list_entry_get_name(cursor)); if( (devnode = udev_device_get_devnode(ud)) ) spawn_server(state->exec_path, devnode); udev_device_unref(ud); } while( (cursor = udev_list_entry_get_next(cursor)) ); udev_enumerate_unref(ue); return 0; }
void udevenum(){ 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); struct udev_device* dev = udev_device_new_from_syspath(udev, path); // If the device matches a recognized device ID, open it const char* product = udev_device_get_sysattr_value(dev, "idProduct"); if(!strcmp(product, P_K70_STR)){ pthread_mutex_lock(&kblistmutex); openusb(dev, 70); pthread_mutex_unlock(&kblistmutex); continue; } if(!strcmp(product, P_K95_STR)){ pthread_mutex_lock(&kblistmutex); openusb(dev, 95); pthread_mutex_unlock(&kblistmutex); continue; } // Free the device if it wasn't used udev_device_unref(dev); } udev_enumerate_unref(enumerator); }
/** * Search udev for usb device with specified idVendor and idProduct */ const char* get_usb_device_syspath(const char* idVendor, const char* idProduct, char* buf) { struct udev* udev; struct udev_enumerate* en; struct udev_list_entry* dev_list_entry; udev = udev_new(); if (udev<0) { return 0; } en = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(en, "usb"); udev_enumerate_add_match_sysattr(en, "idVendor",idVendor); udev_enumerate_add_match_sysattr(en, "idProduct",idProduct); udev_enumerate_scan_devices(en); dev_list_entry = udev_enumerate_get_list_entry(en); if (dev_list_entry == 0 ) { return 0; } sprintf(buf, udev_list_entry_get_name(dev_list_entry)); udev_enumerate_unref(en); udev_unref(udev); return buf; }
bool Renderer::connectEmotiv() { /* Opens Emotiv if Emotiv is only HID Device attached */ struct udev_device *dev; struct udev *udev; struct udev_list_entry *devices, *dev_list_entry; struct udev_enumerate *enumerate; udev = udev_new(); 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) { const char * path = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(udev,path); } emotiv_fd = open(udev_device_get_devnode(dev), O_RDONLY); if (emotiv_fd > 0) { int res = read(emotiv_fd, emotivBuffer, 32); if(res < 0) {perror("read"); return false;} return true; } else { perror("Unable to open device"); return false; } }
static int usb_unmount_dev(const char *devname, struct udev *udev) { struct udev_enumerate *enumerate; struct udev_list_entry *dev_list, *dev_list_entry; struct udev_device *device = NULL, *parent_device = NULL; int device_found = 0; int retval = 0; FILE *remfile = NULL; struct stat buf; enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(enumerate, "block"); udev_enumerate_scan_devices(enumerate); dev_list = udev_enumerate_get_list_entry(enumerate); udev_list_entry_foreach(dev_list_entry, dev_list) { device = udev_device_new_from_syspath(udev, udev_list_entry_get_name(dev_list_entry)); if(!strcmp(udev_device_get_devnode(device), devname)) { device_found = 1; break; } else { udev_device_unref(device); device = NULL; } }
static int loopback_list_get(MountPoint **head) { _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL; struct udev_list_entry *item = NULL, *first = NULL; _cleanup_udev_unref_ struct udev *udev = NULL; int r; assert(head); udev = udev_new(); if (!udev) return -ENOMEM; e = udev_enumerate_new(udev); if (!e) return -ENOMEM; r = udev_enumerate_add_match_subsystem(e, "block"); if (r < 0) return r; r = udev_enumerate_add_match_sysname(e, "loop*"); if (r < 0) return r; r = udev_enumerate_add_match_sysattr(e, "loop/backing_file", NULL); 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) { MountPoint *lb; _cleanup_udev_device_unref_ struct udev_device *d; char *loop; const char *dn; d = udev_device_new_from_syspath(udev, udev_list_entry_get_name(item)); if (!d) return -ENOMEM; dn = udev_device_get_devnode(d); if (!dn) continue; loop = strdup(dn); if (!loop) return -ENOMEM; lb = new0(MountPoint, 1); if (!lb) { free(loop); return -ENOMEM; } lb->path = loop; LIST_PREPEND(mount_point, *head, lb); }
/** * get_rfkill_device_by_index: **/ struct udev_device * get_rfkill_device_by_index (struct udev *udev, guint index) { struct udev_enumerate *enumerate; struct udev_list_entry *devices; struct udev_list_entry *dev_list_entry; struct udev_device *dev; enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(enumerate, "rfkill"); udev_enumerate_scan_devices(enumerate); devices = udev_enumerate_get_list_entry(enumerate); udev_list_entry_foreach(dev_list_entry, devices) { const char *path, *index_c; path = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(udev, path); index_c = udev_device_get_sysattr_value (dev, "index"); if (index_c && atoi(index_c) == index) break; udev_device_unref (dev); dev = NULL; } return dev; }
GamepadController::GamepadController() : m_gamepadDevices(Nix::Gamepads::itemsLengthCap) { m_udev = udev_new(); m_gamepadsMonitor = udev_monitor_new_from_netlink(m_udev, "udev"); udev_monitor_enable_receiving(m_gamepadsMonitor); udev_monitor_filter_add_match_subsystem_devtype(m_gamepadsMonitor, "input", 0); GIOChannel *channel = g_io_channel_unix_new(udev_monitor_get_fd(m_gamepadsMonitor)); g_io_add_watch(channel, GIOCondition(G_IO_IN), static_cast<GIOFunc>(&GamepadController::onGamepadChange), this); g_io_channel_unref(channel); struct udev_enumerate* enumerate = udev_enumerate_new(m_udev); udev_enumerate_add_match_subsystem(enumerate, "input"); udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1"); udev_enumerate_scan_devices(enumerate); struct udev_list_entry* cur; struct udev_list_entry* devs = udev_enumerate_get_list_entry(enumerate); udev_list_entry_foreach(cur, devs) { const char* devname = udev_list_entry_get_name(cur); struct udev_device* device = udev_device_new_from_syspath(m_udev, devname); if (isGamepadDevice(device)) registerDevice(udev_device_get_devnode(device)); udev_device_unref(device); } udev_enumerate_unref(enumerate); }
/* add or remove a ACL for a given uid from all matching devices */ static void apply_acl_to_devices(uid_t uid, int add) { struct udev *udev; struct udev_enumerate *enumerate; struct udev_list_entry *list_entry; /* iterate over all devices tagged with ACL_SET */ udev = udev_new(); enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_tag(enumerate, "udev-acl"); udev_enumerate_scan_devices(enumerate); udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) { struct udev_device *device; const char *node; device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate), udev_list_entry_get_name(list_entry)); if (device == NULL) continue; node = udev_device_get_devnode(device); if (node == NULL) { udev_device_unref(device); continue; } set_facl(node, uid, add); udev_device_unref(device); } udev_enumerate_unref(enumerate); udev_unref(udev); }
int main(int argc, char **argv) { int blight, connector_id; const char *path; struct udev *udev; struct udev_enumerate *e; struct udev_list_entry *entry; struct udev_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); drm_device = udev_device_new_from_syspath(udev, path); break; }
static char *find_device_file (int capability) { struct udev *udev; struct udev_enumerate *enumerate; struct udev_list_entry *devices, *dev_list_entry; struct udev_device *dev; const char *path; char *device = NULL; udev = udev_new(); if (!udev) return NULL; enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_property(enumerate, "MBM_CAPABILITY", gps_capabilities[capability]); 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); dev = udev_device_new_from_syspath(udev, path); if (!udev_device_get_devnode(dev)) continue; device = strdup(udev_device_get_devnode(dev)); udev_device_unref (dev); if (mbm_options_debug ()) { g_debug ("found device %s for capability %s", device, gps_capabilities[capability]); } /* * the code returns the first matching device found */ break; }
QUdevDeviceList QUdevPrivate::getUDevDevicesForSubsystem(const QString &strSubSystem, const QString &strDeviceType, const QString &strParentSubSystem, const QString &strParentDeviceType) { struct udev_enumerate *enumerate = udev_enumerate_new(m_pUdev); struct udev_list_entry *devices = 0; struct udev_list_entry *dev_list_entry = 0; struct udev_device *dev = 0; QList<QUdevDevice> lDevices; if(strSubSystem.isEmpty()) return lDevices; //get subsystem enumerator udev_enumerate_add_match_subsystem(enumerate, strSubSystem.toLatin1().constData()); //perform sysfs scanning udev_enumerate_scan_devices(enumerate); devices = udev_enumerate_get_list_entry(enumerate); //iterate over all devices in the enumeration list udev_list_entry_foreach(dev_list_entry, devices) { QUdevDevice udDev; //create udev device for the sysfs path returned udDev.m_strSysfsPath = QString::fromLatin1(udev_list_entry_get_name(dev_list_entry)); dev = udev_device_new_from_syspath(m_pUdev, udDev.m_strSysfsPath.toLatin1().constData()); //filter the correct device types, ignored if empty device type is specified if(strDeviceType.isEmpty() || (QString::fromLatin1(udev_device_get_devtype(dev)) == strDeviceType)) { //get the path inside /dev udDev.m_strDevPath = QString::fromLatin1(udev_device_get_devnode(dev)); udDev.m_strSubsystem = strSubSystem; udDev.m_strDeviceType = strDeviceType; //if the caller wants a specific parent subsystem/devtype query the sysfs tree here if(!strParentSubSystem.isEmpty() && !strParentDeviceType.isEmpty()) { /* * retrieve the parent device with the subsystem/devtype pair of m_strParentSubSystem/m_strParentDeviceType. * * udev_device_get_parent_with_subsystem_devtype() will walk up the complete tree if needed */ dev = udev_device_get_parent_with_subsystem_devtype(dev, strParentSubSystem.toLatin1().constData(), strParentDeviceType.toLatin1().constData()); } if(dev) { //fill the device information udDev.m_strVendorID = QString::fromLatin1(udev_device_get_sysattr_value(dev,"idVendor")); udDev.m_strProductID = QString::fromLatin1(udev_device_get_sysattr_value(dev, "idProduct")); udDev.m_strManufacturer = QString::fromLatin1(udev_device_get_sysattr_value(dev,"manufacturer")); udDev.m_strProduct = QString::fromLatin1(udev_device_get_sysattr_value(dev,"product")); udDev.m_strSerial = QString::fromLatin1(udev_device_get_sysattr_value(dev, "serial")); lDevices.append(udDev); } udev_device_unref(dev); } }
QStringList QDeviceDiscovery::scanConnectedDevices() { QStringList devices; if (!m_udev) return devices; udev_enumerate *ue = udev_enumerate_new(m_udev); udev_enumerate_add_match_subsystem(ue, "input"); udev_enumerate_add_match_subsystem(ue, "drm"); if (m_types & Device_Mouse) udev_enumerate_add_match_property(ue, "ID_INPUT_MOUSE", "1"); if (m_types & Device_Touchpad) udev_enumerate_add_match_property(ue, "ID_INPUT_TOUCHPAD", "1"); if (m_types & Device_Touchscreen) udev_enumerate_add_match_property(ue, "ID_INPUT_TOUCHSCREEN", "1"); if (m_types & Device_Keyboard) { udev_enumerate_add_match_property(ue, "ID_INPUT_KEYBOARD", "1"); udev_enumerate_add_match_property(ue, "ID_INPUT_KEY", "1"); } if (m_types & Device_Tablet) udev_enumerate_add_match_property(ue, "ID_INPUT_TABLET", "1"); if (udev_enumerate_scan_devices(ue) != 0) { #ifdef QT_QPA_DEVICE_DISCOVERY_DEBUG qWarning() << "UDeviceHelper scan connected devices for enumeration failed"; #endif return devices; } udev_list_entry *entry; udev_list_entry_foreach (entry, udev_enumerate_get_list_entry(ue)) { const char *syspath = udev_list_entry_get_name(entry); udev_device *udevice = udev_device_new_from_syspath(m_udev, syspath); QString candidate = QString::fromUtf8(udev_device_get_devnode(udevice)); if ((m_types & Device_InputMask) && candidate.startsWith(QLatin1String(QT_EVDEV_DEVICE))) devices << candidate; if ((m_types & Device_VideoMask) && candidate.startsWith(QLatin1String(QT_DRM_DEVICE))) { if (m_types & Device_DRM_PrimaryGPU) { udev_device *pci = udev_device_get_parent_with_subsystem_devtype(udevice, "pci", 0); if (pci) { if (qstrcmp(udev_device_get_sysattr_value(pci, "boot_vga"), "1") == 0) devices << candidate; } } else devices << candidate; } udev_device_unref(udevice); } udev_enumerate_unref(ue); #ifdef QT_QPA_DEVICE_DISCOVERY_DEBUG qWarning() << "UDeviceHelper found matching devices" << devices; #endif return devices; }
rw_status_t rw_udev_register_cb(rw_udev_handle_t *handle, void *userdata, rw_udev_cb_t cb) { struct udev_enumerate *enumerate = NULL; struct udev_list_entry *devices, *dev_list_entry; int ret = -1; rw_status_t status = RW_STATUS_SUCCESS; rw_pci_address_t pci_addr; rw_pci_device_t *dev; struct udev_device *udevice; handle->cb = cb; handle->userdata = userdata; //walk throight he list and call the callback.. enumerate = udev_enumerate_new(handle->udev); if (!enumerate){ goto free_and_ret; } udev_enumerate_add_match_subsystem(enumerate, "net"); 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){ }else{ udevice = udev_device_new_from_syspath(handle->udev, path); dev = rw_udev_insert_device(handle, &pci_addr); rw_udev_update_device(udevice, dev); if (dev){ handle->cb(handle->userdata, dev, RW_UDEV_DEVICE_ADD); } udev_device_unref(udevice); } } handle->mon = udev_monitor_new_from_netlink(handle->udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(handle->mon, "net", NULL); udev_monitor_enable_receiving(handle->mon); /* Get the file descriptor (fd) for the monitor. This fd will get passed to select() */ handle->fd = udev_monitor_get_fd(handle->mon); ret: return status; free_and_ret: if (enumerate){ udev_enumerate_unref(enumerate); enumerate = NULL; } status = RW_STATUS_FAILURE; goto ret; }
UdevEnumerator::UdevEnumerator(UdevContext& context) :enumerator(0) { /* Create a new udev enumerator in the given udev context: */ enumerator=udev_enumerate_new(context.context); if(enumerator==0) throw std::runtime_error("RawHID::UdevEnumerator::UdevEnumerator: Cannot create udev enumerator"); }
/* This implementation uses udev to retrieve capture devices. We support both udev and default v4l2 ways to retrieve devices. Udev is not supported on all systems. */ std::vector<V4L2_Device> v4l2_get_devices() { std::vector<V4L2_Device> result; 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 result; } 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) { /* Get the device by syspath. */ const char* syspath = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(udev, syspath); if(!dev) { printf("Error: cannot get the device using the syspath: %s\n", syspath); continue; } V4L2_Device v4l2_device; v4l2_device.path = udev_device_get_devnode(dev); if(v4l2_device.path.size() == 0) { printf("Error: Cannot find devpath.\n"); continue; } dev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device"); if(!dev) { printf("Error:Cannot find related usb device.\n"); continue; } v4l2_device.id_vendor = udev_device_get_sysattr_value(dev, "idVendor"); v4l2_device.id_product = udev_device_get_sysattr_value(dev, "idProduct"); result.push_back(v4l2_device); } udev_enumerate_unref(enumerate); udev_unref(udev); return result; }
udev_enumerate_ptr Root::mk_enumerate() const { udev_enumerate_ptr res (udev_enumerate_new(p.get()) , [](udev_enumerate *p) { if (p) udev_enumerate_unref(p); }); return res; }
int get_usbinfo(int bus, int dev, usbinfo_t *ui) { struct udev *udev; 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 found = 0; memset(ui, 0, sizeof(usbinfo_t)); /* construct xenstore dev id */ if (dev > 0xFFF) { xd_log(LOG_ERR, "bad device id %d", dev); return -EINVAL; } ui->usb_virtid = bus << 12 | (dev & 0xFFF); ui->usb_bus = bus; ui->usb_device = dev; /* udev scan */ udev = udev_new(); if (!udev) { xd_log(LOG_ERR, "Can't create udev"); return -ENOMEM; } enumerate = udev_enumerate_new(udev); 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, path); sscanf(udev_device_get_sysattr_value(udev_dev, "idVendor"), "%x", &ui->usb_vendor); sscanf(udev_device_get_sysattr_value(udev_dev, "idProduct"), "%x", &ui->usb_product); udev_device_unref(udev_dev); udev_enumerate_unref(enumerate); udev_unref(udev); return 0; } udev_enumerate_unref(enumerate); udev_unref(udev); return -ENOENT; }
void input_init(char* mapfile) { #ifdef HAVE_LIBCEC init_cec(); #endif udev = udev_new(); if (!udev) { fprintf(stderr, "Can't create udev\n"); exit(1); } autoadd = (numDevices == 0); if (autoadd) { 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) { input_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); udev_fdindex = numFds++; sig_fdindex = numFds++; if (fds == NULL) fds = malloc(sizeof(struct pollfd)*numFds); else fds = realloc(fds, sizeof(struct pollfd)*numFds); if (fds == NULL) { fprintf(stderr, "Not enough memory\n"); exit(EXIT_FAILURE); } defaultMapfile = mapfile; fds[udev_fdindex].fd = udev_monitor_get_fd(udev_mon); fds[udev_fdindex].events = POLLIN; main_thread_id = pthread_self(); }
static char * get_render_node_from_id_path_tag(struct udev *udev, char *id_path_tag, char another_tag) { struct udev_device *device; struct udev_enumerate *e; struct udev_list_entry *entry; const char *path, *id_path_tag_tmp; char *path_res; char found = 0; UDEV_SYMBOL(struct udev_enumerate *, udev_enumerate_new, (struct udev *)); UDEV_SYMBOL(int, udev_enumerate_add_match_subsystem, (struct udev_enumerate *, const char *)); UDEV_SYMBOL(int, udev_enumerate_add_match_sysname, (struct udev_enumerate *, const char *)); UDEV_SYMBOL(int, udev_enumerate_scan_devices, (struct udev_enumerate *)); UDEV_SYMBOL(struct udev_list_entry *, udev_enumerate_get_list_entry, (struct udev_enumerate *)); UDEV_SYMBOL(struct udev_list_entry *, udev_list_entry_get_next, (struct udev_list_entry *)); UDEV_SYMBOL(const char *, udev_list_entry_get_name, (struct udev_list_entry *)); UDEV_SYMBOL(struct udev_device *, udev_device_new_from_syspath, (struct udev *, const char *)); UDEV_SYMBOL(const char *, udev_device_get_property_value, (struct udev_device *, const char *)); UDEV_SYMBOL(const char *, udev_device_get_devnode, (struct udev_device *)); UDEV_SYMBOL(struct udev_device *, udev_device_unref, (struct udev_device *)); e = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(e, "drm"); udev_enumerate_add_match_sysname(e, "render*"); 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); if (!device) continue; id_path_tag_tmp = udev_device_get_property_value(device, "ID_PATH_TAG"); if (id_path_tag_tmp) { if ((!another_tag && !strcmp(id_path_tag, id_path_tag_tmp)) || (another_tag && strcmp(id_path_tag, id_path_tag_tmp))) { found = 1; break; } } udev_device_unref(device); }
void GamepadInit(void) { struct udev_list_entry* devices; struct udev_list_entry* item; struct udev_enumerate* enu; int i; /* initialize connection state */ for (i = 0; i != GAMEPAD_COUNT; ++i) { STATE[i].flags = 0; STATE[i].fd = STATE[i].effect = -1; } /* open the udev handle */ UDEV = udev_new(); if (UDEV == NULL) { /* FIXME: flag error? */ return; } /* open monitoring device (safe to fail) */ MON = udev_monitor_new_from_netlink(UDEV, "udev"); /* FIXME: flag error if hot-plugging can't be supported? */ if (MON != NULL) { udev_monitor_enable_receiving(MON); udev_monitor_filter_add_match_subsystem_devtype(MON, "input", NULL); } /* enumerate joypad devices */ enu = udev_enumerate_new(UDEV); udev_enumerate_add_match_subsystem(enu, "input"); udev_enumerate_scan_devices(enu); devices = udev_enumerate_get_list_entry(enu); udev_list_entry_foreach(item, devices) { const char* name; const char* sysPath; const char* devPath; struct udev_device* dev; name = udev_list_entry_get_name(item); dev = udev_device_new_from_syspath(UDEV, name); sysPath = udev_device_get_syspath(dev); devPath = udev_device_get_devnode(dev); if (sysPath != NULL && devPath != NULL && strstr(sysPath, "/js") != 0) { GamepadAddDevice(devPath); } udev_device_unref(dev); } /* cleanup */ udev_enumerate_unref(enu); }
/* * this function is not powerful because it reinitializes a new udev search each * time it would be nicer to call this only one time + one time at each hotplug * but it is already very fast, so, let's keep it simple and non intrusive */ bool CLinuxInputDevices::IsUdevJoystick(const char *devpath) { #if defined(HAVE_LIBUDEV) struct udev *udev; struct udev_enumerate *enumerate; struct udev_list_entry *devices, *dev_list_entry; struct udev_device *dev; const char *path; const char *devfoundpath; udev = udev_new(); if (!udev) return false; // can't create udev enumerate = udev_enumerate_new(udev); if (enumerate == NULL) { udev_unref(udev); return false; } if (udev_enumerate_add_match_subsystem(enumerate, "input") == 0) { if (udev_enumerate_add_match_property(enumerate, "ID_INPUT_JOYSTICK", "1") == 0) { if (udev_enumerate_scan_devices(enumerate) >= 0) { devices = udev_enumerate_get_list_entry(enumerate); udev_list_entry_foreach(dev_list_entry, devices) { path = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(udev, path); if (dev != NULL) { devfoundpath = udev_device_get_devnode(dev); if (devfoundpath != NULL) { // found (finally !) //printf("=> %s\n", devfoundpath); if (strcmp(devfoundpath, devpath) == 0) { udev_device_unref(dev); udev_enumerate_unref(enumerate); udev_unref(udev); return true; } } udev_device_unref(dev); } } } }
int find_and_open_p6s() { int result = -1; char buf[300]; memset(buf, 0, sizeof(buf)); get_usb_device_syspath(ID_VENDOR_YEALINK,ID_PRODUCT_VOIPUSBPHONE, buf); int len = strlen(buf); if (len==0) { return result; } printf("Found Skypemate P6S USB at %s \n", buf); struct udev* udev; struct udev_enumerate* enumerate; struct udev_list_entry* dev_list_entry; struct udev_device* dev; udev = udev_new(); if (udev<0) { perror("error creating udev object"); return result; } // enumerating all hidraw devices enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(enumerate, "hidraw"); udev_enumerate_scan_devices(enumerate); dev_list_entry = udev_enumerate_get_list_entry(enumerate); while ((dev_list_entry!=0) && (result==-1)) { const char* syspath = udev_list_entry_get_name(dev_list_entry); dev = udev_device_new_from_syspath(udev, syspath); // get hidraw USB parent struct udev_device* parent = udev_device_get_parent_with_subsystem_devtype(dev, "usb","usb_device"); if (parent != 0) { const char* parent_syspath = udev_device_get_syspath(parent); if ( strcmp(buf, parent_syspath) == 0) { // found it const char* devnode = udev_device_get_devnode(dev); printf("Found corresponding hidraw device: %s \n", devnode); result = open(devnode, O_RDONLY); } } udev_device_unref(dev); dev_list_entry = udev_list_entry_get_next(dev_list_entry); } udev_enumerate_unref(enumerate); udev_unref(udev); return result; }
//we have no seat filters, we account all input devices and all dce6 display //devices void lwl_udev_input_cold_plug(void) { struct udev_enumerate *e; e=udev_enumerate_new(lwl_udev); if(!e){ PERRC("fatal:cold plug:unable to create enumeration\n"); exit(LWL_ERR); } int r=udev_enumerate_add_match_subsystem(e,"input"); if(r){ PERRC("fatal:cold plug:unable to select input subsystem for enumeration\n"); exit(LWL_ERR); } r=udev_enumerate_add_match_subsystem(e,"dce6_display"); if(r){ PERRC("fatal:cold plug:unable to select dce6_display subsystem for" " enumeration\n"); exit(LWL_ERR); } r=udev_enumerate_scan_devices(e); if(r){ PERRC("fatal:cold plug:error while enumerating input devices\n"); exit(LWL_ERR); } struct udev_list_entry *first=udev_enumerate_get_list_entry(e); struct udev_list_entry *item=0; LOG_UDEV("cold plug:starting input devices enumeration...\n"); udev_list_entry_foreach(item,first){ struct udev_device *d=udev_device_new_from_syspath(lwl_udev, udev_list_entry_get_name(item)); if(!d) continue; void *subsys=(void*)udev_device_get_subsystem(d); if(!strncmp(INPUT_STR,subsys,cs_n(INPUT_STR))) input_device_add(d); else if(!strncmp(DCE6_DISPLAY_STR,subsys,cs_n(DCE6_DISPLAY_STR))){ struct gbl *o=output_plugged(d); if(o) registry_gbl_ref(o); } udev_device_unref(d); } LOG_UDEV("cold plug:end of input devices enumeration\n"); udev_enumerate_unref(e); }
static void do_list_local () { struct udev *udev; struct udev_enumerate *enumerate; struct udev_list_entry *devices, *dev_list_entry; struct udev_device *dev; const gchar *path; const gchar *idVendor; const gchar *idProduct; const gchar *bConfValue; const gchar *bNumIntfs; const gchar *busid; /* Create libudev context. */ udev = udev_new (); /* Create libudev device enumeration. */ enumerate = udev_enumerate_new (udev); /* Take only USB devices that are not hubs and do not have * the bInterfaceNumber attribute, i.e. are not interfaces. */ udev_enumerate_add_match_subsystem (enumerate, "usb"); udev_enumerate_add_nomatch_sysattr (enumerate, "bDeviceClass", "09"); udev_enumerate_add_nomatch_sysattr (enumerate, "bInterfaceNumber", NULL); udev_enumerate_scan_devices (enumerate); devices = udev_enumerate_get_list_entry (enumerate); /* Show information about each device. */ udev_list_entry_foreach (dev_list_entry, devices) { path = udev_list_entry_get_name (dev_list_entry); dev = udev_device_new_from_syspath (udev, path); /* Get device information. */ idVendor = udev_device_get_sysattr_value (dev, "idVendor"); idProduct = udev_device_get_sysattr_value (dev, "idProduct"); bConfValue = udev_device_get_sysattr_value (dev, "bConfigurationValue"); bNumIntfs = udev_device_get_sysattr_value (dev, "bNumInterfaces"); busid = udev_device_get_sysname (dev); if (!idVendor || !idProduct || !bConfValue || !bNumIntfs) { g_printerr ("problem getting device attributes: %s\n", g_strerror (errno)); break; } g_print (" - busid %s (%.4s:%.4s)\n\n", busid, idVendor, idProduct); udev_device_unref (dev); }