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; }
/** * 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; }
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 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; }
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; } }
/* 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); }
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); }
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); }
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); }
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); }
/* * Cleans up resources and set exception that will get thrown upon return to java layer. */ jstring linux_listusb_clean_throw_exp(JNIEnv *env, int task, const char *expmsg, struct jstrarray_list *list, struct udev_device *udev_device, struct udev_enumerate *enumerator, struct udev *udev_ctx) { (*env)->ExceptionClear(env); free_jstrarraylist(list); /* free memory first, so even if throwing JNI exception fails, this succeeds. */ if(task == 1) { udev_device_unref(udev_device); udev_enumerate_unref(enumerator); udev_unref(udev_ctx); }else { } jclass serialComExceptionClass = (*env)->FindClass(env, SCOMEXPCLASS); if((serialComExceptionClass == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) { (*env)->ExceptionClear(env); if(task == 1) { LOGE(E_FINDCLASSSCOMEXPSTR, E_NEWSTRUTFSTR); }else { LOGE(E_FINDCLASSSCOMEXPSTR, expmsg); } return NULL; } if(task == 1) { (*env)->ThrowNew(env, serialComExceptionClass, E_NEWSTRUTFSTR); }else { (*env)->ThrowNew(env, serialComExceptionClass, expmsg); } return NULL; }
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; }
static virInterfacePtr udevInterfaceLookupByMACString(virConnectPtr conn, const char *macstr) { struct udev_iface_driver *driverState = conn->interfacePrivateData; struct udev *udev = udev_ref(driverState->udev); struct udev_enumerate *enumerate = NULL; struct udev_list_entry *dev_entry; struct udev_device *dev; const char *name; virInterfacePtr ret = NULL; enumerate = udevGetDevices(udev, VIR_UDEV_IFACE_ALL); if (!enumerate) { virReportError(VIR_ERR_INTERNAL_ERROR, _("failed to lookup interface with MAC address '%s'"), macstr); goto err; } /* Match on MAC */ udev_enumerate_add_match_sysattr(enumerate, "address", macstr); /* Do the scan to load up the enumeration */ udev_enumerate_scan_devices(enumerate); /* Get a list we can walk */ dev_entry = udev_enumerate_get_list_entry(enumerate); /* Check that we got something back */ if (!dev_entry) { virReportError(VIR_ERR_NO_INTERFACE, _("couldn't find interface with MAC address '%s'"), macstr); goto err; } /* Check that we didn't get multiple items back */ if (udev_list_entry_get_next(dev_entry)) { virReportError(VIR_ERR_MULTIPLE_INTERFACES, _("the MAC address '%s' matches multiple interfaces"), macstr); goto err; } dev = udev_device_new_from_syspath(udev, udev_list_entry_get_name(dev_entry)); name = udev_device_get_sysname(dev); ret = virGetInterface(conn, name, macstr); udev_device_unref(dev); err: if (enumerate) udev_enumerate_unref(enumerate); udev_unref(udev); return ret; }
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; }
/* 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; }
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(); }
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 int udevNumOfInterfacesByStatus(virConnectPtr conn, virUdevStatus status, virInterfaceObjListFilter filter) { struct udev_iface_driver *driverState = conn->interfacePrivateData; struct udev *udev = udev_ref(driverState->udev); struct udev_enumerate *enumerate = NULL; struct udev_list_entry *devices; struct udev_list_entry *dev_entry; int count = 0; enumerate = udevGetDevices(udev, status); if (!enumerate) { virReportError(VIR_ERR_INTERNAL_ERROR, _("failed to get number of %s interfaces on host"), virUdevStatusString(status)); count = -1; goto cleanup; } /* Do the scan to load up the enumeration */ udev_enumerate_scan_devices(enumerate); /* Get a list we can walk */ devices = udev_enumerate_get_list_entry(enumerate); /* For each item so we can count */ udev_list_entry_foreach(dev_entry, devices) { struct udev_device *dev; const char *path; virInterfaceDefPtr def; path = udev_list_entry_get_name(dev_entry); dev = udev_device_new_from_syspath(udev, path); def = udevGetMinimalDefForDevice(dev); if (filter(conn, def)) count++; udev_device_unref(dev); virInterfaceDefFree(def); } cleanup: if (enumerate) udev_enumerate_unref(enumerate); udev_unref(udev); return count; }
int show_sysfs(const char *seat, const char *prefix, unsigned n_columns) { struct udev *udev; struct udev_list_entry *first = NULL; struct udev_enumerate *e; int r; if (n_columns <= 0) n_columns = columns(); if (!prefix) prefix = ""; if (isempty(seat)) seat = "seat0"; udev = udev_new(); if (!udev) return -ENOMEM; e = udev_enumerate_new(udev); if (!e) { r = -ENOMEM; goto finish; } if (!streq(seat, "seat0")) r = udev_enumerate_add_match_tag(e, seat); else r = udev_enumerate_add_match_tag(e, "seat"); if (r < 0) goto finish; r = udev_enumerate_scan_devices(e); if (r < 0) goto finish; first = udev_enumerate_get_list_entry(e); if (first) show_sysfs_one(udev, seat, &first, "/", prefix, n_columns); finish: if (e) udev_enumerate_unref(e); if (udev) udev_unref(udev); return r; }
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 usb_dongle_probe(struct udev *udev, const char *subsystem) { struct udev_enumerate *udev_enumerate; int ret; mylog_trace("%s enumerate '%s'", __func__, subsystem == NULL ? "<all>" : subsystem); udev_enumerate = udev_enumerate_new(udev); if (udev_enumerate == NULL) return -1; udev_enumerate_add_match_subsystem(udev_enumerate, subsystem); udev_enumerate_scan_devices(udev_enumerate); ret = usb_dongle_probe_print_list(udev_enumerate); udev_enumerate_unref(udev_enumerate); return ret; }
int Storage::enumerate_mmcblk_devices(struct udev *udev) { struct udev_enumerate *udev_enumerate; qDebug() << Q_FUNC_INFO << ": enumerate 'block' devices"; udev_enumerate = udev_enumerate_new(udev); if (udev_enumerate == NULL) return -1; udev_enumerate_add_match_subsystem(udev_enumerate,"block"); udev_enumerate_scan_devices(udev_enumerate); struct udev_list_entry *list_entry; udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(udev_enumerate)) { struct udev_device *device; device = udev_device_new_from_syspath(udev_enumerate_get_udev(udev_enumerate), udev_list_entry_get_name(list_entry)); if (device != NULL) { QString sysname("/dev/"); sysname += QString(udev_device_get_sysname(device)); if (sysname.contains(QRegExp("mmcblk[1-9]\\d*")) || sysname.contains(QRegExp("mmcblk[1-9]"))) { QString path = udev_device_get_devpath(device); QString parent = udev_device_get_devpath( udev_device_get_parent (device)); QString action = "add"; QString devtype = udev_device_get_devtype(device); qDebug() << "Enumerate device " << path << ":" << action; qDebug() << " Got Device"; qDebug() << " Node: " << udev_device_get_devnode(device); qDebug() << " Subsystem: "<< udev_device_get_subsystem(device); qDebug() << " Devtype: " << devtype; qDebug() << " Action: " << action; qDebug() << " Sysname: " << sysname; qDebug() << " sysnum: " << udev_device_get_sysnum (device); qDebug() << " parent: " << parent; processRemovableUdevEvents(devtype, path, sysname, action); } udev_device_unref(device); } } udev_enumerate_unref(udev_enumerate); return 0; }
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(); }
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; }
bool QUdevService::isPropertyAvailable(const char *property, const char *value) { bool available = false; struct udev_enumerate *enumerate = 0; if (context) { if ((enumerate = udev_enumerate_new(context)) && (0 == udev_enumerate_add_match_property(enumerate, property, value)) && (0 == udev_enumerate_scan_devices(enumerate))) { available = (0 != udev_enumerate_get_list_entry(enumerate)); } } if (enumerate) udev_enumerate_unref(enumerate); return available; }
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; }