自学教程：C++ udev_monitor_filter_add_match_subsystem_devtype函数代码示例

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()));}

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 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);  }}

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;}

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()));        }

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);}

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;}

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);}

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;}

rw_status_trw_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 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);}

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 UdevMonitor::addSubsystemFilter(const char* subsystem,const char* deviceType)	{	/* Add a subsystem filter: */	if(udev_monitor_filter_add_match_subsystem_devtype(monitor,subsystem,deviceType)!=0)		throw std::runtime_error("RawHID::UdevMonitor::addSubsystemFilter: Internal libudev error");		/* If the monitor is already listening, update its filters: */	if(listening)		if(udev_monitor_filter_update(monitor)!=0)			throw std::runtime_error("RawHID::UdevMonitor::addSubsystemFilter: Internal libudev error");	}

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);}

intmain(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;}

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 ClientPrivate::setWatchedSubsystems(const QStringList &subsystemList){    // create a listener    struct udev_monitor *newM = udev_monitor_new_from_netlink(udev, "udev");    if (!newM) {        qCWarning(POWERDEVIL, "UdevQt: unable to create udev monitor connection");        return;    }    // apply our filters; an empty list means listen to everything    Q_FOREACH (const QString& subsysDevtype, subsystemList) {        int ix = subsysDevtype.indexOf(u'/');        if (ix > 0) {            QByteArray subsystem = subsysDevtype.leftRef(ix).toLatin1();            QByteArray devType = subsysDevtype.midRef(ix + 1).toLatin1();            udev_monitor_filter_add_match_subsystem_devtype(newM, subsystem.constData(), devType.constData());        } else {            udev_monitor_filter_add_match_subsystem_devtype(newM, subsysDevtype.toLatin1().constData(), NULL);        }    }

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;        }()){}

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;}

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()));}

/* * 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();	}} 

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)));}

static intudev_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;}

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);}

    void DeviceManager::initHotplug()    {        udev * uDev;        udev_enumerate * uDevEnum;        udev_list_entry * uDevList;        udev_list_entry * uDevListEntry;        udev_device * device;        uDev = udev_new();        if (!uDev)        {            LOG("[DeviceManager] Could not initialize udev! HID passthrough will be disabled./n");            return;        }        hotplugMonitor = udev_monitor_new_from_netlink(uDev, "udev");        udev_monitor_filter_add_match_subsystem_devtype(hotplugMonitor, "hidraw", nullptr);        udev_monitor_enable_receiving(hotplugMonitor);        fdHotplug = udev_monitor_get_fd(hotplugMonitor);        uDevEnum = udev_enumerate_new(uDev);        udev_enumerate_add_match_subsystem(uDevEnum, "hidraw");        udev_enumerate_scan_devices(uDevEnum);        uDevList = udev_enumerate_get_list_entry(uDevEnum);        udev_list_entry_foreach(uDevListEntry, uDevList)        {            const char * devicePath;            devicePath = udev_list_entry_get_name(uDevListEntry);            device = udev_device_new_from_syspath(uDev, devicePath);            add(new DeviceHard(udev_device_get_devnode(device)));            udev_device_unref(device);        }        udev_enumerate_unref(uDevEnum);    }