void QNetworkInfoPrivate::connectNotify(const QMetaMethod &signal) { #if !defined(QT_NO_OFONO) if (QOfonoWrapper::isOfonoAvailable()) { if (!ofonoWrapper) ofonoWrapper = new QOfonoWrapper(this); QMetaMethod sourceSignal = proxyToSourceSignal(signal, ofonoWrapper); connect(ofonoWrapper, sourceSignal, this, signal, Qt::UniqueConnection); } #endif static const QMetaMethod currentNetworkModeChangedSignal = QMetaMethod::fromSignal(&QNetworkInfoPrivate::currentNetworkModeChanged); static const QMetaMethod networkNameChangedSignal = QMetaMethod::fromSignal(&QNetworkInfoPrivate::networkNameChanged); static const QMetaMethod networkSignalStrengthChangedSignal = QMetaMethod::fromSignal(&QNetworkInfoPrivate::networkSignalStrengthChanged); static const QMetaMethod networkStatusChangedSignal = QMetaMethod::fromSignal(&QNetworkInfoPrivate::networkStatusChanged); // we always monitor "networkInterfaceCount" , as long as users connect any signals, // with update to date network interface counts, we can compute network mode, strength, // status, name properties in an efficient way if (!watchNetworkInterfaceCount) { QList<QNetworkInfo::NetworkMode> modes; modes << QNetworkInfo::WlanMode << QNetworkInfo::EthernetMode << QNetworkInfo::BluetoothMode; networkInterfaceCounts.clear(); foreach (QNetworkInfo::NetworkMode mode, modes) networkInterfaceCounts[mode] = getNetworkInterfaceCount(mode); #if !defined(QT_NO_UDEV) if (!udevHandle) { udevHandle = udev_new(); udevMonitor = udev_monitor_new_from_netlink(udevHandle, "udev"); udev_monitor_filter_add_match_subsystem_devtype(udevMonitor, "net", NULL); udev_monitor_enable_receiving(udevMonitor); udevNotifier = new QSocketNotifier(udev_monitor_get_fd(udevMonitor), QSocketNotifier::Read, this); connect(udevNotifier, SIGNAL(activated(int)), this, SLOT(onUdevChanged())); }
static int sixaxis_init(void) { GIOChannel *channel; DBG(""); ctx = udev_new(); if (!ctx) return -EIO; monitor = udev_monitor_new_from_netlink(ctx, "udev"); if (!monitor) { udev_unref(ctx); ctx = NULL; return -EIO; } /* Listen for newly connected hidraw interfaces */ udev_monitor_filter_add_match_subsystem_devtype(monitor, "hidraw", NULL); udev_monitor_enable_receiving(monitor); channel = g_io_channel_unix_new(udev_monitor_get_fd(monitor)); watch_id = g_io_add_watch(channel, G_IO_IN, monitor_watch, NULL); g_io_channel_unref(channel); return 0; }
QUdevPrivate::QUdevPrivate(QUdev *parent) : m_pUdev(0), q_ptr(parent), m_bMonitoringActive(false) { qRegisterMetaType<QUdevEvent>("QUdevEvent"); //fill the action map m_mUdevActions[QString("add")] = eDeviceAdd; m_mUdevActions[QString("remove")] = eDeviceRemove; m_mUdevActions[QString("change")] = eDeviceChange; m_mUdevActions[QString("online")] = eDeviceOnline; m_mUdevActions[QString("offline")] = eDeviceOffline; //create the udev object m_pUdev = udev_new(); //set up a udev monitor object m_pMon = udev_monitor_new_from_netlink(m_pUdev, "udev"); Q_ASSERT(m_pUdev); Q_ASSERT(m_pMon); udev_monitor_enable_receiving(m_pMon); }
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); }
QDeviceDiscovery::QDeviceDiscovery(QDeviceTypes types, struct udev *udev, QObject *parent) : QObject(parent), m_types(types), m_udev(udev), m_udevMonitor(0), m_udevMonitorFileDescriptor(-1), m_udevSocketNotifier(0) { #ifdef QT_QPA_DEVICE_DISCOVERY_DEBUG qWarning() << "New UDeviceHelper created for type" << types; #endif if (!m_udev) return; m_udevMonitor = udev_monitor_new_from_netlink(m_udev, "udev"); if (!m_udevMonitor) { #ifdef QT_QPA_DEVICE_DISCOVERY_DEBUG qWarning("Unable to create an Udev monitor. No devices can be detected."); #endif return; } udev_monitor_filter_add_match_subsystem_devtype(m_udevMonitor, "input", 0); udev_monitor_filter_add_match_subsystem_devtype(m_udevMonitor, "drm", 0); udev_monitor_enable_receiving(m_udevMonitor); m_udevMonitorFileDescriptor = udev_monitor_get_fd(m_udevMonitor); m_udevSocketNotifier = new QSocketNotifier(m_udevMonitorFileDescriptor, QSocketNotifier::Read, this); connect(m_udevSocketNotifier, SIGNAL(activated(int)), this, SLOT(handleUDevNotification())); }
UdevNotifier::UdevNotifier(QString const & subsystem, QObject * parent/* = nullptr*/) : QObject(parent) , d(new Impl) { d->udev = udev_new(); d->monitor = udev_monitor_new_from_netlink(d->udev, "udev"); if (nullptr == d->monitor) { qWarning() << QStringLiteral("UdevNotifier: unable to initialize udev_monitor, monitoring will be disabled"); return; } int ret = udev_monitor_filter_add_match_subsystem_devtype(d->monitor, subsystem.toUtf8().constData(), nullptr); if (0 != ret) qWarning() << QStringLiteral("UdevNotifier: unable to add match subsystem, monitor will receive all devices"); ret = udev_monitor_enable_receiving(d->monitor); if (0 != ret) { qWarning() << QStringLiteral("UdevNotifier: unable to enable receiving(%1), monitoring will be disabled").arg(ret); return; } d->notifier.reset(new QSocketNotifier(udev_monitor_get_fd(d->monitor), QSocketNotifier::Read)); connect(d->notifier.data(), &QSocketNotifier::activated, this, &UdevNotifier::eventReady); d->notifier->setEnabled(true); }
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; }
int linux_udev_start_event_monitor(void) { int r; if (NULL == udev_ctx) { udev_ctx = udev_new(); if (!udev_ctx) { 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"); return LIBUSB_ERROR_OTHER; } 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"); return LIBUSB_ERROR_OTHER; } if (udev_monitor_enable_receiving(udev_monitor)) { usbi_err(NULL, "failed to enable the udev monitor"); return LIBUSB_ERROR_OTHER; } udev_monitor_fd = udev_monitor_get_fd(udev_monitor); pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL); return LIBUSB_SUCCESS; }
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; }
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(); }
int udev_handler::start_monitor() { monitor = udev_monitor_new_from_netlink(udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(monitor, "hid", NULL); udev_monitor_filter_add_match_subsystem_devtype(monitor, "input", NULL); udev_monitor_enable_receiving(monitor); monitor_thread = new std::thread(&udev_handler::read_monitor, this); return 0; }
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); }
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); }
int main(int argc, char *argv[]) { struct udev *udev; // struct udev_enumerate *enumerate; // struct udev_list_entry *devices, *device; udev_monitor = NULL; struct udev_device *udev_device; const char *action; udev = udev_new(); if (!udev) { printf("udev_new failed\n"); return 0; } udev_monitor = udev_monitor_new_from_netlink(udev, "udev"); if (!udev_monitor) { printf("udev_monitor_new_from_netlink failed\n"); return 0; } udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "input", NULL); if (udev_monitor_enable_receiving(udev_monitor)) { printf("config/udev: failed to bind the udev monitor\n"); return 0; } int udev_fd = udev_monitor_get_fd(udev_monitor); select_for_read(udev_fd); udev_device = udev_monitor_receive_device(udev_monitor); if (!udev_device) { printf("udev_monitor_receive_device failed\n"); return 0; } action = udev_device_get_action(udev_device); printf("udev action %s\n", action); if (action) { if (!strcmp(action, "add") || !strcmp(action, "change")) { printf("device_removed(udev_device); device_added(udev_device);\n"); } else if (!strcmp(action, "remove")) { printf("device_removed(udev_device);\n"); } } udev_device_unref(udev_device); 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; }
gboolean testdisplay_setup_hotplug(void) { int ret; udev = udev_new(); if (!udev) { igt_warn("failed to create udev object\n"); goto out; } uevent_monitor = udev_monitor_new_from_netlink(udev, "udev"); if (!uevent_monitor) { igt_warn("failed to create udev event monitor\n"); goto out; } ret = udev_monitor_filter_add_match_subsystem_devtype(uevent_monitor, "drm", "drm_minor"); if (ret < 0) { igt_warn("failed to filter for drm events\n"); goto out; } ret = udev_monitor_enable_receiving(uevent_monitor); if (ret < 0) { igt_warn("failed to enable udev event reception\n"); goto out; } udevchannel = g_io_channel_unix_new(udev_monitor_get_fd(uevent_monitor)); if (!udevchannel) { igt_warn("failed to create udev GIO channel\n"); goto out; } ret = g_io_add_watch(udevchannel, G_IO_IN | G_IO_ERR, hotplug_event, udev); if (ret < 0) { igt_warn("failed to add watch on udev GIO channel\n"); goto out; } return TRUE; out: testdisplay_cleanup_hotplug(); return FALSE; }
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; }
void lwl_udev_init(i ep_fd) { lwl_udev=udev_new(); if(!lwl_udev){ PERRC("fatal:unable to init udev context\n"); exit(LWL_ERR); } //get events *after* udev rule engine processing monitor=udev_monitor_new_from_netlink(lwl_udev,"udev"); if(!monitor){ PERRC("fatal:unable to create an udev monitor\n"); exit(LWL_ERR); } l r=(l)udev_monitor_filter_add_match_subsystem_devtype(monitor,INPUT_STR,0); if(r<0){ PERRC("fatal:unable to add " INPUT_STR " subsystem match to udev monitor\n"); exit(LWL_ERR); } r=(l)udev_monitor_filter_add_match_subsystem_devtype(monitor,DCE6_DISPLAY_STR, 0); if(r<0){ PERRC("fatal:unable to add " DCE6_DISPLAY_STR " subsystem match to udev monitor\n"); exit(LWL_ERR); } r=(l)udev_monitor_enable_receiving(monitor); if(r<0){ PERRC("fatal:unable to enable receiving of udev monitor events\n"); exit(LWL_ERR); } i monitor_fd=udev_monitor_get_fd(monitor); struct epoll_event ep_evt; memset(&ep_evt,0,sizeof(ep_evt)); ep_evt.events=EPOLLIN|EPOLLHUP;//*level* triggered ep_evt.data._32=EPOLL_UDEV; r=epoll_ctl(ep_fd,EPOLL_CTL_ADD,monitor_fd,&ep_evt); if(ISERR(r)){ PERR("fatal(%ld):unable to register udev monitor socket(%d) to epoll\n",r, monitor_fd); exit(LWL_ERR); } }
Monitor::Monitor(Root const &udev, char const *subsystem, char const *devtype) : fd_(-1) , h_([&udev, subsystem, devtype, this]() { auto h = udev.mk_monitor("udev"); if (!h) throw cor::Error("Can't create udev monitor"); udev_monitor_filter_add_match_subsystem_devtype (h.get(), subsystem, devtype); udev_monitor_enable_receiving(h_.get()); fd_ = udev_monitor_get_fd(h_.get()); return h; }()) { }
int main () { udev = udev_new(); if(!udev) { fprintf(stderr, "Can't create udev.\n"); exit(EXIT_FAILURE); } mon = udev_monitor_new_from_netlink(udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL); udev_monitor_enable_receiving(mon); while(1) { if (mon != NULL) FD_SET(udev_monitor_get_fd(mon), &readfds); select(udev_monitor_get_fd(mon) + 1, &readfds, NULL, NULL, NULL); if ((mon != NULL) && FD_ISSET(udev_monitor_get_fd(mon), &readfds)) { dev = udev_monitor_receive_device(mon); if(dev) { device = (char *) udev_device_get_sysname(dev); } } devnum = udev_device_get_devnum(dev); major = major(devnum); minor = minor(devnum); action = udev_device_get_action(dev); printf("Processing device %s %d:%d\n", action, major, minor); struct udev_list_entry * props = udev_device_get_properties_list_entry(dev); while(props != NULL) { printf("%s = %s\n", udev_list_entry_get_name(props), udev_list_entry_get_value(props)); props = udev_list_entry_get_next (props); } props = udev_device_get_sysattr_list_entry(dev); while(props != NULL) { printf("%s = %s\n", udev_list_entry_get_name(props), udev_device_get_sysattr_value(dev, udev_list_entry_get_name(props))); props = udev_list_entry_get_next (props); } } return 0; }
void CALSADeviceMonitor::Start() { int err; if (!m_udev) { m_udev = udev_new(); if (!m_udev) { CLog::Log(LOGWARNING, "CALSADeviceMonitor::Start - Unable to open udev handle"); return; } m_udevMonitor = udev_monitor_new_from_netlink(m_udev, "udev"); if (!m_udevMonitor) { CLog::Log(LOGERROR, "CALSADeviceMonitor::Start - udev_monitor_new_from_netlink() failed"); goto err_unref_udev; } err = udev_monitor_filter_add_match_subsystem_devtype(m_udevMonitor, "sound", NULL); if (err) { CLog::Log(LOGERROR, "CALSADeviceMonitor::Start - udev_monitor_filter_add_match_subsystem_devtype() failed"); goto err_unref_monitor; } err = udev_monitor_enable_receiving(m_udevMonitor); if (err) { CLog::Log(LOGERROR, "CALSADeviceMonitor::Start - udev_monitor_enable_receiving() failed"); goto err_unref_monitor; } g_fdEventMonitor.AddFD( CFDEventMonitor::MonitoredFD(udev_monitor_get_fd(m_udevMonitor), POLLIN, FDEventCallback, m_udevMonitor), m_fdMonitorId); } return; err_unref_monitor: udev_monitor_unref(m_udevMonitor); m_udevMonitor = NULL; err_unref_udev: udev_unref(m_udev); m_udev = NULL; }
PowerExcessHandler::PowerExcessHandler(QObject *parent): QObject(parent), d_ptr(new PowerExcessHandlerPrivate) { Q_D(PowerExcessHandler); d->udevHandle = udev_new(); d->udevMonitor = udev_monitor_new_from_netlink(d->udevHandle, "udev"); udev_monitor_filter_add_match_subsystem_devtype(d->udevMonitor, "misc", 0); udev_monitor_enable_receiving(d->udevMonitor); d->udevSocketNotifier = new QSocketNotifier(udev_monitor_get_fd(d->udevMonitor), QSocketNotifier::Read, this); connect(d->udevSocketNotifier, SIGNAL(activated(int)), this, SLOT(handleUdevNotification())); }
void UdevMonitor::listen(void) { /* Bail out if the monitor is already listening: */ if(listening) return; /* Start listening: */ if(udev_monitor_enable_receiving(monitor)!=0) throw std::runtime_error("RawHID::UdevMonitor::listen: Internal libudev error"); listening=true; /* Set the monitor's event socket to blocking: */ int fdFlags=fcntl(fd,F_GETFL); fdFlags&=~O_NONBLOCK; fcntl(fd,F_SETFL,fdFlags); }
Storage::Storage() : privatePartition(NULL) , publicPartition(NULL) , removablePartition(NULL) , dataPartition(NULL) , usb_active(false) { qDebug() << Q_FUNC_INFO; _partitions = QMap<QString, StoragePartition*>(); _devices = QMap<QString, StorageDevice*>(); udev = udev_new(); if (!udev) { qDebug() << Q_FUNC_INFO << "Cannot create udev"; return; } enumerate_mmcblk_devices(udev); udev_monitor = udev_monitor_new_from_netlink(udev, "udev"); if (!udev_monitor) { qDebug() << Q_FUNC_INFO << "Cannot create mon"; return; } if (udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "block", NULL) != 0) { qDebug() << Q_FUNC_INFO << "Error with udev_monitor_filter_add_match_subsystem_devtype"; return; } udev_monitor_set_receive_buffer_size(udev_monitor, UDEV_MONITOR_BUFFER_SIZE_STORAGE); if (udev_monitor_enable_receiving(udev_monitor) < 0) { qDebug() << Q_FUNC_INFO << "Error, cannot receive from kernel"; return; } int fd = udev_monitor_get_fd(udev_monitor); if (fd <= 0) { qDebug() << Q_FUNC_INFO << "Error at udev_monitor_get_fd"; return; } notifier = new QSocketNotifier(fd, QSocketNotifier::Read, this); notifier->setEnabled(true); connect(notifier, SIGNAL(activated(int)), this, SLOT(checkDevice(int))); }
/* * Initiate the device list (with udev monitoring) * args: * none * * asserts: * none * * returns: none */ void v4l2core_init_device_list() { /* Create a udev object */ my_device_list.udev = udev_new(); /*start udev device monitoring*/ /* Set up a monitor to monitor v4l2 devices */ if(my_device_list.udev) { my_device_list.udev_mon = udev_monitor_new_from_netlink(my_device_list.udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(my_device_list.udev_mon, "video4linux", NULL); udev_monitor_enable_receiving(my_device_list.udev_mon); /* Get the file descriptor (fd) for the monitor */ my_device_list.udev_fd = udev_monitor_get_fd(my_device_list.udev_mon); enum_v4l2_devices(); } }
static int udev_start(void) { int fd; if (udev) { syslog(LOG_ERR, "udev: already started"); return -1; } syslog(LOG_DEBUG, "udev: starting"); udev = udev_new(); if (udev == NULL) { syslog(LOG_ERR, "udev_new: %m"); return -1; } monitor = udev_monitor_new_from_netlink(udev, "udev"); if (monitor == NULL) { syslog(LOG_ERR, "udev_monitor_new_from_netlink: %m"); goto bad; } #ifndef LIBUDEV_NOFILTER if (udev_monitor_filter_add_match_subsystem_devtype(monitor, "net", NULL) != 0) { syslog(LOG_ERR, "udev_monitor_filter_add_match_subsystem_devtype: %m"); goto bad; } #endif if (udev_monitor_enable_receiving(monitor) != 0) { syslog(LOG_ERR, "udev_monitor_enable_receiving: %m"); goto bad; } fd = udev_monitor_get_fd(monitor); if (fd == -1) { syslog(LOG_ERR, "udev_monitor_get_fd: %m"); goto bad; } return fd; bad: udev_stop(); return -1; }
void CUDevProvider::Initialize() { CLog::Log(LOGDEBUG, "Selected UDev as storage provider"); m_udev = udev_new(); if (!m_udev) { CLog::Log(LOGERROR, "%s - failed to allocate udev context", __FUNCTION__); return; } /* set up a devices monitor that listen for any device change */ m_udevMon = udev_monitor_new_from_netlink(m_udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(m_udevMon, "block", "disk"); udev_monitor_filter_add_match_subsystem_devtype(m_udevMon, "block", "partition"); udev_monitor_enable_receiving(m_udevMon); PumpDriveChangeEvents(NULL); }
int main (int argc, char* argv[]) { struct udev *udev; struct udev_device *dev; struct udev_monitor *mon; int fd; /* Create the udev object */ udev = udev_new(); if (!udev) { printf("Can't create udev\n"); exit(1); } /* Set up a monitor to monitor power_supply devices */ mon = udev_monitor_new_from_netlink(udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(mon, "power_supply", NULL); udev_monitor_enable_receiving(mon); printf("[INFO] Monitoring...\n"); while (1) { dev = udev_monitor_receive_device(mon); if (dev) { if(strcmp(udev_device_get_sysname(dev), "ADP1") == 0) { printf("\n [DEBUG] Found ADP1\n"); if(strcmp(udev_device_get_sysattr_value(dev, "online"), "1") == 0) { printf("\n [INFO] AC Adapter State: Online\n"); changeBrightness(937); } else if (strcmp(udev_device_get_sysattr_value(dev, "online"), "1") < 0) { printf("\n [INFO] AC Adapter State: Offline\n"); changeBrightness(92); } } } udev_device_unref(dev); sleep(2); } udev_unref(udev); return 0; }
UdevListener::UdevListener(QObject *parent) : QObject(parent) { udev = udev_new(); if (!udev) { return; } /* Set up a monitor to monitor hid devices */ mon = udev_monitor_new_from_netlink(udev, "udev"); udev_monitor_filter_add_match_subsystem_devtype(mon, "hid", NULL); udev_monitor_enable_receiving(mon); fd = udev_monitor_get_fd(mon); socketNotifier = new QSocketNotifier(fd, QSocketNotifier::Read, this); connect(socketNotifier, SIGNAL(activated(int)), this, SLOT(fdActivated(int))); }
void UdevDeviceNotifier::init() { m_udev = udev_new(); if (!m_udev) { return; } m_monitor = udev_monitor_new_from_netlink(m_udev, "udev"); if (!m_monitor) { return; } udev_monitor_filter_add_match_subsystem_devtype(m_monitor, "input", 0); udev_monitor_enable_receiving(m_monitor); int monitor_fd = udev_monitor_get_fd(m_monitor); QSocketNotifier *notifier = new QSocketNotifier(monitor_fd, QSocketNotifier::Read, this); connect(notifier, &QSocketNotifier::activated, this, &UdevDeviceNotifier::socketActivated); }