void manager_free(Manager *m) { Network *network; NetDev *netdev; Link *link; if (!m) return; udev_monitor_unref(m->udev_monitor); udev_unref(m->udev); sd_bus_unref(m->bus); sd_event_source_unref(m->udev_event_source); sd_event_source_unref(m->sigterm_event_source); sd_event_source_unref(m->sigint_event_source); sd_event_unref(m->event); while ((network = m->networks)) network_free(network); while ((link = hashmap_first(m->links))) link_free(link); hashmap_free(m->links); while ((netdev = hashmap_first(m->netdevs))) netdev_free(netdev); hashmap_free(m->netdevs); sd_rtnl_unref(m->rtnl); free(m); }
int linux_udev_stop_event_monitor(void) { char dummy = 1; int r; assert(udev_ctx != NULL); assert(udev_monitor != NULL); assert(udev_monitor_fd != -1); /* Write some dummy data to the control pipe and * wait for the thread to exit */ r = usbi_write(udev_control_pipe[1], &dummy, sizeof(dummy)); if (r <= 0) { usbi_warn(NULL, "udev control pipe signal failed"); } pthread_join(linux_event_thread, NULL); /* Release the udev monitor */ udev_monitor_unref(udev_monitor); udev_monitor = NULL; udev_monitor_fd = -1; /* Clean up the udev context */ udev_unref(udev_ctx); udev_ctx = NULL; /* close and reset control pipe */ close(udev_control_pipe[0]); close(udev_control_pipe[1]); udev_control_pipe[0] = -1; udev_control_pipe[1] = -1; return LIBUSB_SUCCESS; }
static int vlc_sd_probe_Open (vlc_object_t *obj) { vlc_probe_t *probe = (vlc_probe_t *)obj; struct udev *udev = udev_new (); if (udev == NULL) return VLC_PROBE_CONTINUE; struct udev_monitor *mon = udev_monitor_new_from_netlink (udev, "udev"); if (mon != NULL) { vlc_sd_probe_Add (probe, "v4l{longname=\"Video capture\"}", N_("Video capture"), SD_CAT_DEVICES); #ifdef HAVE_ALSA if (!module_exists ("pulselist")) vlc_sd_probe_Add (probe, "alsa{longname=\"Audio capture\"}", N_("Audio capture"), SD_CAT_DEVICES); #endif vlc_sd_probe_Add (probe, "disc{longname=\"Discs\"}", N_("Discs"), SD_CAT_DEVICES); udev_monitor_unref (mon); } udev_unref (udev); return VLC_PROBE_CONTINUE; }
void manager_free(Manager *m) { Network *network; Bridge *bridge; Link *link; udev_monitor_unref(m->udev_monitor); udev_unref(m->udev); sd_bus_unref(m->bus); sd_event_source_unref(m->udev_event_source); sd_event_unref(m->event); while ((network = m->networks)) network_free(network); while ((link = hashmap_first(m->links))) link_free(link); hashmap_free(m->links); while ((bridge = hashmap_first(m->bridges))) bridge_free(bridge); hashmap_free(m->bridges); sd_rtnl_unref(m->rtnl); free(m); }
int linux_udev_start_event_monitor(void) { int r; assert(udev_ctx == NULL); udev_ctx = udev_new(); if (!udev_ctx) { usbi_err(NULL, "could not create udev context"); return LIBUSB_ERROR_OTHER; } udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev"); if (!udev_monitor) { usbi_err(NULL, "could not initialize udev monitor"); goto err_free_ctx; } r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0); if (r) { usbi_err(NULL, "could not initialize udev monitor filter for \"usb\" subsystem"); goto err_free_monitor; } if (udev_monitor_enable_receiving(udev_monitor)) { usbi_err(NULL, "failed to enable the udev monitor"); goto err_free_monitor; } udev_monitor_fd = udev_monitor_get_fd(udev_monitor); /* Some older versions of udev are not non-blocking by default, * so make sure this is set */ r = fcntl(udev_monitor_fd, F_GETFL); if (r == -1) { usbi_err(NULL, "getting udev monitor fd flags (%d)", errno); goto err_free_monitor; } r = fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK); if (r) { usbi_err(NULL, "setting udev monitor fd flags (%d)", errno); goto err_free_monitor; } r = pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL); if (r) { usbi_err(NULL, "creating hotplug event thread (%d)", r); goto err_free_monitor; } return LIBUSB_SUCCESS; err_free_monitor: udev_monitor_unref(udev_monitor); udev_monitor = NULL; udev_monitor_fd = -1; err_free_ctx: udev_unref(udev_ctx); udev_ctx = NULL; return LIBUSB_ERROR_OTHER; }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->udev_io) m->core->mainloop->io_free(u->udev_io); if (u->monitor) udev_monitor_unref(u->monitor); if (u->udev) udev_unref(u->udev); if (u->inotify_io) m->core->mainloop->io_free(u->inotify_io); if (u->inotify_fd >= 0) pa_close(u->inotify_fd); if (u->devices) pa_hashmap_free(u->devices); pa_xfree(u); }
UdevListener::~UdevListener() { delete socketNotifier; udev_monitor_unref(mon); udev_unref(udev); }
void pa__done(pa_module *m) { struct userdata *u; pa_assert(m); if (!(u = m->userdata)) return; if (u->udev_io) m->core->mainloop->io_free(u->udev_io); if (u->monitor) udev_monitor_unref(u->monitor); if (u->udev) udev_unref(u->udev); if (u->inotify_io) m->core->mainloop->io_free(u->inotify_io); if (u->inotify_fd >= 0) pa_close(u->inotify_fd); if (u->devices) { struct device *d; while ((d = pa_hashmap_steal_first(u->devices))) device_free(d); pa_hashmap_free(u->devices, NULL, NULL); } pa_xfree(u); }
static void manager_free(struct manager *m) { unsigned int i; struct link *l; if (!m) return; while ((l = MANAGER_FIRST_LINK(m))) link_free(l); manager_dbus_disconnect(m); shl_htable_clear_uint(&m->links, NULL, NULL); sd_event_source_unref(m->udev_mon_source); udev_monitor_unref(m->udev_mon); udev_unref(m->udev); for (i = 0; m->sigs[i]; ++i) sd_event_source_unref(m->sigs[i]); sd_bus_unref(m->bus); sd_event_unref(m->event); free(m->friendly_name); free(m); }
static void udev_input_free(void *data) { unsigned i; udev_input_t *udev = (udev_input_t*)data; if (!data || !udev) return; if (udev->joypad) udev->joypad->destroy(); epoll_free(&udev->epfd); for (i = 0; i < udev->num_devices; i++) { close(udev->devices[i]->fd); free(udev->devices[i]); } free(udev->devices); if (udev->monitor) udev_monitor_unref(udev->monitor); if (udev->udev) udev_unref(udev->udev); udev_input_kb_free(); free(udev); }
ClientPrivate::~ClientPrivate() { udev_unref(udev); delete monitorNotifier; if (monitor) udev_monitor_unref(monitor); }
QDeviceDiscovery::~QDeviceDiscovery() { if (m_udevMonitor) udev_monitor_unref(m_udevMonitor); if (m_udev) udev_unref(m_udev); }
void deInitaccessory(Accessory* accessory) { udev_monitor_unref(accessory->udev_monitor); udev_unref(accessory->udev_context); libusb_exit(accessory->usb_context); bt_close(accessory->bt_service); free(accessory); }
UdevSubsystem::~UdevSubsystem() { if (m_monitor) { udev_monitor_unref(m_monitor); } udev_unref(m_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; }
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); }
udev_monitor_ptr Root::mk_monitor(char const *name) const { udev_monitor_ptr res (udev_monitor_new_from_netlink(p.get(), name) , [](udev_monitor *p) { if (p) udev_monitor_unref(p); }); return res; }
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); }
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(); }
void DeviceManager::finiHotplug() { if (fdHotplug >= 0) { close(fdHotplug); udev_monitor_unref(hotplugMonitor); fdHotplug = -255; } }
void joystick_linux::monitor_joysticks(udev *p_udev) { udev_device *dev = NULL; udev_monitor *mon = udev_monitor_new_from_netlink(p_udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(mon, "input", NULL); udev_monitor_enable_receiving(mon); int fd = udev_monitor_get_fd(mon); while (!exit_udev) { fd_set fds; struct timeval tv; int ret; FD_ZERO(&fds); FD_SET(fd, &fds); tv.tv_sec = 0; tv.tv_usec = 0; ret = select(fd+1, &fds, NULL, NULL, &tv); /* Check if our file descriptor has received data. */ if (ret > 0 && FD_ISSET(fd, &fds)) { /* Make the call to receive the device. select() ensured that this will not block. */ dev = udev_monitor_receive_device(mon); if (dev && udev_device_get_devnode(dev) != 0) { joy_mutex->lock(); String action = udev_device_get_action(dev); const char* devnode = udev_device_get_devnode(dev); if (devnode) { String devnode_str = devnode; if (devnode_str.find(ignore_str) == -1) { if (action == "add") open_joystick(devnode); else if (String(action) == "remove") close_joystick(get_joy_from_path(devnode)); } } udev_device_unref(dev); joy_mutex->unlock(); } } usleep(50000); } //printf("exit udev\n"); udev_monitor_unref(mon); }
void UdevEventPublisher::tearDown() { WriteLock lock(mutex_); if (monitor_ != nullptr) { udev_monitor_unref(monitor_); monitor_ = nullptr; } if (handle_ != nullptr) { udev_unref(handle_); handle_ = nullptr; } }
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; } }
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; }
static void udev_stop(void) { if (monitor) { udev_monitor_unref(monitor); monitor = NULL; } if (udev) { udev_unref(udev); udev = NULL; } }
int usbmain(){ // Load the uinput module (if it's not loaded already) if(system("modprobe uinput") != 0) ckb_warn("Failed to load uinput module\n"); // Create the udev object if(!(udev = udev_new())){ ckb_fatal("Failed to initialize udev\n"); return -1; } // Enumerate all currently connected devices udev_enum(); // Done scanning. Enter a loop to poll for device updates struct udev_monitor* monitor = udev_monitor_new_from_netlink(udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(monitor, "usb", 0); udev_monitor_enable_receiving(monitor); // Get an fd for the monitor int fd = udev_monitor_get_fd(monitor); fd_set fds; while(udev){ FD_ZERO(&fds); FD_SET(fd, &fds); // Block until an event is read if(select(fd + 1, &fds, 0, 0, 0) > 0 && FD_ISSET(fd, &fds)){ struct udev_device* dev = udev_monitor_receive_device(monitor); if(!dev) continue; const char* action = udev_device_get_action(dev); if(!action){ udev_device_unref(dev); continue; } // Add/remove device if(!strcmp(action, "add")){ int res = usb_add_device(dev); if(res == 0) continue; // If the device matched but the handle wasn't opened correctly, re-enumerate (this sometimes solves the problem) if(res == -1) udev_enum(); } else if(!strcmp(action, "remove")) usb_rm_device(dev); udev_device_unref(dev); } } udev_monitor_unref(monitor); return 0; }
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); }