QDeviceDiscovery::~QDeviceDiscovery() { if (m_udevMonitor) udev_monitor_unref(m_udevMonitor); if (m_udev) udev_unref(m_udev); }
UdevSubsystem::~UdevSubsystem() { if (m_monitor) { udev_monitor_unref(m_monitor); } udev_unref(m_udev); }
void joystick_linux::run_joystick_thread() { udev *_udev = udev_new(); ERR_FAIL_COND(!_udev); enumerate_joysticks(_udev); monitor_joysticks(_udev); udev_unref(_udev); }
ClientPrivate::~ClientPrivate() { udev_unref(udev); delete monitorNotifier; if (monitor) udev_monitor_unref(monitor); }
/* 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 testdisplay_cleanup_hotplug(void) { if (udevchannel) g_io_channel_shutdown(udevchannel, TRUE, NULL); if (uevent_monitor) udev_monitor_unref(uevent_monitor); if (udev) udev_unref(udev); }
udev_handler::~udev_handler() { if (monitor_thread) { stop_thread = true; monitor_thread->join(); delete monitor_thread; } if (monitor) udev_monitor_unref(monitor); if (udev) udev_unref(udev); }
UdevDeviceNotifier::~UdevDeviceNotifier() { if (m_monitor) { udev_monitor_unref(m_monitor); } if (m_udev) { udev_unref(m_udev); } }
LinuxDeviceManager::~LinuxDeviceManager() { setDefaultBlockedState(/*state=*/false); // FIXME: Set to previous state stop(); udev_monitor_unref(_umon); udev_unref(_udev); close(_event_fd); return; }
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; }
int usbip_vhci_driver_open(void) { udev_context = udev_new(); if (!udev_context) { err("udev_new failed"); return -1; } vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver)); /* will be freed in usbip_driver_close() */ vhci_driver->hc_device = udev_device_new_from_subsystem_sysname(udev_context, USBIP_VHCI_BUS_TYPE, USBIP_VHCI_DEVICE_NAME); if (!vhci_driver->hc_device) { err("udev_device_new_from_subsystem_sysname failed"); goto err; } vhci_driver->nports = get_nports(); dbg("available ports: %d", vhci_driver->nports); if (vhci_driver->nports <= 0) { err("no available ports"); goto err; } else if (vhci_driver->nports > MAXNPORT) { err("port number exceeds %d", MAXNPORT); goto err; } vhci_driver->ncontrollers = get_ncontrollers(); dbg("available controllers: %d", vhci_driver->ncontrollers); if (vhci_driver->ncontrollers <=0) { err("no available usb controllers"); goto err; } if (refresh_imported_device_list()) goto err; return 0; err: udev_device_unref(vhci_driver->hc_device); if (vhci_driver) free(vhci_driver); vhci_driver = NULL; udev_unref(udev_context); return -1; }
QUdevPrivate &QUdevPrivate::operator=(const QUdevPrivate& Other) { if(this != &Other) { if(m_pUdev) udev_unref(m_pUdev); m_pUdev = Other.m_pUdev; m_lMonitorEntries = Other.m_lMonitorEntries; } return *this; }
QNetworkInfoPrivate::~QNetworkInfoPrivate() { #if !defined(QT_NO_UDEV) if (udevMonitor) udev_monitor_unref(udevMonitor); if (udevHandle) udev_unref(udevHandle); #endif // QT_NO_UDEV }
GamepadController::~GamepadController() { udev_unref(m_udev); udev_monitor_unref(m_gamepadsMonitor); for (unsigned i = 0; i <= m_gamepadDevices.size(); i++) delete m_gamepadDevices[i]; m_gamepadDevices.clear(); }
LibinputServer::~LibinputServer() { #ifdef KEY_INPUT_HANDLING_VIRTUAL if (m_virtualkeyboard != nullptr) { Destruct(m_virtualkeyboard); } #endif libinput_unref(m_libinput); udev_unref(m_udev); }
void JoypadLinux::run_joypad_thread() { #ifdef UDEV_ENABLED udev *_udev = udev_new(); ERR_FAIL_COND(!_udev); enumerate_joypads(_udev); monitor_joypads(_udev); udev_unref(_udev); #else monitor_joypads(); #endif }
/** * Search all Joystick devices */ gboolean search_devices(GList **list_controllers) { int i; Controller_info *ctrl_info; struct udev *udev; struct udev_device *dev; for(i = 0; i < 32; ++i) { gchar *str = NULL; str = g_strdup_printf("/dev/input/js%d", i); int fd = open(str, O_RDONLY); if (fd < 0) { //printf("Could not found joystick: %s\n", str->str); break; } else { ctrl_info = g_malloc(sizeof(Controller_info)); uint8_t num_axis = 0; uint8_t num_button = 0; ioctl(fd, JSIOCGAXES, &num_axis); ioctl(fd, JSIOCGBUTTONS, &num_button); ctrl_info->filename = g_strdup(str); ctrl_info->num_axis = num_axis; ctrl_info->num_buttons = num_button; // Get Name char name_c_str[1024]; if (ioctl(fd, JSIOCGNAME(sizeof(name_c_str)), name_c_str) < 0) { printf("%s : %s", str, strerror(errno)); break; } else { ctrl_info->name = g_convert_with_fallback(name_c_str, sizeof(name_c_str), "UTF-8", "ISO-8859-1", NULL, NULL, NULL, NULL); } /* Create the udev object */ udev = udev_new(); if (!udev) { printf("Can't create udev\n"); exit(0); } dev = udev_device_new_from_subsystem_sysname(udev, "input", g_strdup_printf("js%d", i)); if (dev == NULL) break; ctrl_info->serial = uint32_atoi(g_strdup_printf("%s%s", udev_list_entry_get_value(udev_list_entry_get_by_name(udev_device_get_properties_list_entry(dev), "ID_VENDOR_ID")), udev_list_entry_get_value(udev_list_entry_get_by_name(udev_device_get_properties_list_entry(dev), "ID_MODEL_ID")))); udev_device_unref(dev); udev_unref(udev); printf("%s : %d, %d, 0x%08x\n", ctrl_info->name, ctrl_info->num_axis, ctrl_info->num_buttons, ctrl_info->serial); } *list_controllers = g_list_append(*list_controllers, ctrl_info); close(fd); } return TRUE; }
int udev_init_library_context(void) { if (_udev) udev_unref(_udev); if (!(_udev = udev_new())) { log_error("Failed to create udev library context."); return 0; } return 1; }
void CALSADeviceMonitor::Stop() { if (m_udev) { g_fdEventMonitor.RemoveFD(m_fdMonitorId); udev_monitor_unref(m_udevMonitor); m_udevMonitor = NULL; udev_unref(m_udev); m_udev = NULL; } }
void UdevEventPublisher::tearDown() { WriteLock lock(mutex_); if (monitor_ != nullptr) { udev_monitor_unref(monitor_); monitor_ = nullptr; } if (handle_ != nullptr) { udev_unref(handle_); handle_ = nullptr; } }
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 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; }
char * dri2_get_driver_for_fd(int fd) { struct udev *udev; struct udev_device *device, *parent; const char *pci_id; char *driver = NULL; int vendor_id, chip_id, i, j; udev = udev_new(); device = dri2_udev_device_new_from_fd(udev, fd); if (device == NULL) return NULL; parent = udev_device_get_parent(device); if (parent == NULL) { _eglLog(_EGL_WARNING, "DRI2: could not get parent device"); goto out; } pci_id = udev_device_get_property_value(parent, "PCI_ID"); if (pci_id == NULL || sscanf(pci_id, "%x:%x", &vendor_id, &chip_id) != 2) { _eglLog(_EGL_WARNING, "EGL-DRI2: malformed or no PCI ID"); goto out; } for (i = 0; driver_map[i].driver; i++) { if (vendor_id != driver_map[i].vendor_id) continue; if (driver_map[i].num_chips_ids == -1) { driver = strdup(driver_map[i].driver); _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s", fd, vendor_id, chip_id, driver); goto out; } for (j = 0; j < driver_map[i].num_chips_ids; j++) if (driver_map[i].chip_ids[j] == chip_id) { driver = strdup(driver_map[i].driver); _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s", fd, vendor_id, chip_id, driver); goto out; } } out: udev_device_unref(device); udev_unref(udev); return driver; }
void usbip_vhci_driver_close() { if (!vhci_driver) return; udev_device_unref(vhci_driver->hc_device); free(vhci_driver); vhci_driver = NULL; udev_unref(udev_context); }
static void sixaxis_exit(void) { DBG(""); g_source_remove(watch_id); watch_id = 0; udev_monitor_unref(monitor); monitor = NULL; udev_unref(ctx); ctx = NULL; }
int main(int argc, char **argv) { struct udev *udev; int retval = 0; char maj_min_dev[MAX_PATH_LEN]; int newargc; char **newargv; udev = udev_new(); if (udev == NULL) goto exit; log_open(); udev_set_log_fn(udev, log_fn); /* * Get config file options. */ newargv = NULL; retval = get_file_options(udev, NULL, NULL, &newargc, &newargv); if (retval < 0) { retval = 1; goto exit; } if (newargv && (retval == 0)) { if (set_options(udev, newargc, newargv, short_options, maj_min_dev) < 0) { retval = 2; goto exit; } free(newargv); } /* * Get command line options (overriding any config file settings). */ if (set_options(udev, argc, argv, short_options, maj_min_dev) < 0) exit(1); if (!dev_specified) { log_error("no device specified\n"); retval = 1; goto exit; } retval = scsi_id(udev, maj_min_dev); exit: udev_unref(udev); log_close(); return retval; }
UdevContext & UdevContext::operator=(const UdevContext &other) { if (this != &other) { ScopeLock protect(udev_context_mutex); struct udev *new_ud = (nullptr == other.ud) ? udev_ref(other.ud) : nullptr; assert(nullptr == other.ud || nullptr != new_ud); if (ud != nullptr) udev_unref(ud); ud = new_ud; } return *this; }
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 udev_open(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options) { struct udev_data *mdata = data; struct udev_device *device; bool value; const struct sol_flow_node_type_udev_boolean_options *opts = (const struct sol_flow_node_type_udev_boolean_options *)options; SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options, SOL_FLOW_NODE_TYPE_UDEV_BOOLEAN_OPTIONS_API_VERSION, -EINVAL); mdata->udev = udev_new(); SOL_NULL_CHECK(mdata->udev, -EINVAL); mdata->monitor = udev_monitor_new_from_netlink(mdata->udev, "udev"); if (!mdata->monitor) { SOL_WRN("Fail on create the udev monitor"); goto monitor_error; } if (udev_monitor_enable_receiving(mdata->monitor) < 0) { SOL_WRN("error: unable to subscribe to udev events"); goto receive_error; } mdata->addr = strdup(opts->address); mdata->node = node; mdata->watch = sol_fd_add(udev_monitor_get_fd(mdata->monitor), SOL_FD_FLAGS_IN | SOL_FD_FLAGS_ERR | SOL_FD_FLAGS_HUP, _on_event, mdata); device = udev_device_new_from_syspath(mdata->udev, mdata->addr); if (device) { value = true; udev_device_unref(device); } else { value = false; } return sol_flow_send_boolean_packet(node, SOL_FLOW_NODE_TYPE_UDEV_BOOLEAN__OUT__OUT, value); receive_error: mdata->monitor = udev_monitor_unref(mdata->monitor); monitor_error: mdata->udev = udev_unref(mdata->udev); return -EINVAL; }
static void udev_close(struct sol_flow_node *node, void *data) { struct udev_data *mdata = data; if (mdata->watch) { sol_fd_del(mdata->watch); mdata->watch = NULL; } mdata->monitor = udev_monitor_unref(mdata->monitor); mdata->udev = udev_unref(mdata->udev); free(mdata->addr); }