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

static intudev_handle_device(void *ctx){	struct udev_device *device;	const char *subsystem, *ifname, *action;	device = udev_monitor_receive_device(monitor);	if (device == NULL) {		syslog(LOG_ERR, "libudev: received NULL device");		return -1;	}	subsystem = udev_device_get_subsystem(device);	ifname = udev_device_get_sysname(device);	action = udev_device_get_action(device);	/* udev filter documentation says "usually" so double check */	if (strcmp(subsystem, "net") == 0) {		syslog(LOG_DEBUG, "%s: libudev: %s", ifname, action);		if (strcmp(action, "add") == 0 || strcmp(action, "move") == 0)			dhcpcd.handle_interface(ctx, 1, ifname);		else if (strcmp(action, "remove") == 0)			dhcpcd.handle_interface(ctx, -1, ifname);	}	udev_device_unref(device);	return 1;}

void CALSADeviceMonitor::FDEventCallback(int id, int fd, short revents, void *data){  struct udev_monitor *udevMonitor = (struct udev_monitor *)data;  bool audioDevicesChanged = false;  struct udev_device *device;  while ((device = udev_monitor_receive_device(udevMonitor)) != NULL)  {    const char* action = udev_device_get_action(device);    const char* soundInitialized = udev_device_get_property_value(device, "SOUND_INITIALIZED");    if (!action || !soundInitialized)      continue;    /* cardX devices emit a "change" event when ready (i.e. all subdevices added) */    if (strcmp(action, "change") == 0)    {      CLog::Log(LOGDEBUG, "CALSADeviceMonitor - ALSA card added (/"%s/", /"%s/")", udev_device_get_syspath(device), udev_device_get_devpath(device));      audioDevicesChanged = true;    }    else if (strcmp(action, "remove") == 0)    {      CLog::Log(LOGDEBUG, "CALSADeviceMonitor - ALSA card removed");      audioDevicesChanged = true;    }    udev_device_unref(device);  }  if (audioDevicesChanged)  {    CServiceBroker::GetActiveAE()->DeviceChange();  }}

void Storage::checkDevice(int fd) {    PowerManagerLock* powerLock = PowerManager::getNewLock(this);    powerLock->activate();    qDebug() << Q_FUNC_INFO << "FD: "<< fd;    struct udev_device *dev;    dev = udev_monitor_receive_device(udev_monitor);    if (dev)    {        QString device = udev_device_get_devnode(dev);        QString path = udev_device_get_devpath(dev);        QString action = udev_device_get_action(dev);        QString devtype = udev_device_get_devtype(dev);        QString sysname("/dev/");        sysname += QString(udev_device_get_sysname(dev));        QString parent = udev_device_get_devpath( udev_device_get_parent (dev));        if (sysname.contains(QRegExp("mmcblk[0-9]//d*"))  || sysname.contains(QRegExp("mmcblk[0-9]")))        {            qDebug() << "Got " << path << ":" << action;            qDebug() << "    Got Device";            qDebug() << "    Node: " <<  udev_device_get_devnode(dev);            qDebug() << "    Subsystem: "<< udev_device_get_subsystem(dev);            qDebug() << "    Devtype: " << devtype;            qDebug() << "    Action: " << action;            qDebug() << "    Sysname: " << sysname;            qDebug() << "    sysnum: " << udev_device_get_sysnum (dev);            qDebug() << "    parent: " << parent;            processRemovableUdevEvents(devtype, path, sysname, action);        }        udev_device_unref(dev);    }    delete powerLock;}

static void monitor_cb(        pa_mainloop_api*a,        pa_io_event* e,        int fd,        pa_io_event_flags_t events,        void *userdata) {    struct userdata *u = userdata;    struct udev_device *dev;    pa_assert(a);    if (!(dev = udev_monitor_receive_device(u->monitor))) {        pa_log("Failed to get udev device object from monitor.");        goto fail;    }    if (!path_get_card_id(udev_device_get_devpath(dev))) {        udev_device_unref(dev);        return;    }    process_device(u, dev);    udev_device_unref(dev);    return;fail:    a->io_free(u->udev_io);    u->udev_io = NULL;}

static void *Run (void *data){    services_discovery_t *sd = data;    services_discovery_sys_t *p_sys = sd->p_sys;    struct udev_monitor *mon = p_sys->monitor;    int fd = udev_monitor_get_fd (mon);    struct pollfd ufd = { .fd = fd, .events = POLLIN, };    for (;;)    {        while (poll (&ufd, 1, -1) == -1)            if (errno != EINTR)                break;        int canc = vlc_savecancel ();        struct udev_device *dev = udev_monitor_receive_device (mon);        if (dev == NULL)            continue;        const char *action = udev_device_get_action (dev);        if (!strcmp (action, "add"))            AddDevice (sd, dev);        else if (!strcmp (action, "remove"))            RemoveDevice (sd, dev);        else if (!strcmp (action, "change"))        {            RemoveDevice (sd, dev);            AddDevice (sd, dev);        }        udev_device_unref (dev);        vlc_restorecancel (canc);    }    return NULL;}

    void DeviceManager::processHotplugEvents()    {        udev_device * device;        device = udev_monitor_receive_device(hotplugMonitor);        if (device)        {            if (string(udev_device_get_action(device)) == "remove")            {                map <string, Device *>::iterator it;                for (it = devices.begin(); it != devices.end(); it++)                {                    if (it->second->getNode() == udev_device_get_devnode(device))                    {                        Device * dev = it->second;                        remove(dev);                        delete dev;                        break;                    }                }            }            else            {                add(new DeviceHard(udev_device_get_devnode(device)));            }            udev_device_unref(device);        }    }

static monome_t *monitor_attach(detector_state_t *state) {	struct udev_device *ud;	struct pollfd fds[1];	fds[0].fd = udev_monitor_get_fd(state->um);	fds[0].events = POLLIN;	do {		if( poll(fds, 1, -1) < 0 )			switch( errno ) {			case EINVAL:				perror("error in poll()");				exit(1);			case EINTR:			case EAGAIN:				continue;			}		ud = udev_monitor_receive_device(state->um);		/* check if this was an add event.		   "add"[0] == 'a' */		if( *(udev_device_get_action(ud)) == 'a' )			spawn_server(state->exec_path, udev_device_get_devnode(ud));		udev_device_unref(ud);	} while( 1 );}

  void LinuxDeviceManager::udevReceiveDevice()  {    struct udev_device *dev = udev_monitor_receive_device(_umon);    if (!dev) {      return;    }    const char *action_cstr = udev_device_get_action(dev);    if (!action_cstr) {      log->warn("BUG? Device event witout action value.");      udev_device_unref(dev);      return;    }    if (strcmp(action_cstr, "add") == 0) {      processDeviceInsertion(dev);    }    else if (strcmp(action_cstr, "remove") == 0) {      processDeviceRemoval(dev);    }    else {      log->warn("BUG? Unknown device action value /"{}/"", action_cstr);    }    udev_device_unref(dev);    return;  }

static gboolean hotplug_event(GIOChannel *source, GIOCondition condition,			      gpointer data){	struct udev_device *dev;	dev_t udev_devnum;	struct stat s;	const char *hotplug;	dev = udev_monitor_receive_device(uevent_monitor);	if (!dev)		goto out;	udev_devnum = udev_device_get_devnum(dev);	fstat(drm_fd, &s);	hotplug = udev_device_get_property_value(dev, "HOTPLUG");	if (memcmp(&s.st_rdev, &udev_devnum, sizeof(dev_t)) == 0 &&	    hotplug && atoi(hotplug) == 1)		update_display(true);	udev_device_unref(dev);out:	return TRUE;}

UdevDevice UdevMonitor::receiveDeviceEvent(void)	{	/* Wait for and receive a device event: */	udev_device* result=udev_monitor_receive_device(monitor);		/* Return an event object (which might be invalid in case of error or non-blocking event socket): */	return UdevDevice(result);	}

static void udev_input_handle_hotplug(udev_input_t *udev){   bool is_keyboard, is_mouse, is_touchpad;   struct udev_device *dev  = udev_monitor_receive_device(udev->monitor);   device_handle_cb cb      = NULL;   const char *devtype      = NULL;   const char *val_keyboard = NULL;   const char *val_mouse    = NULL;   const char *val_touchpad = NULL;   const char *action       = NULL;   const char *devnode      = NULL;   if (!dev)      return;   val_keyboard  = udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD");   val_mouse     = udev_device_get_property_value(dev, "ID_INPUT_MOUSE");   val_touchpad  = udev_device_get_property_value(dev, "ID_INPUT_TOUCHPAD");   action        = udev_device_get_action(dev);   devnode       = udev_device_get_devnode(dev);   is_keyboard   = val_keyboard && !strcmp(val_keyboard, "1") && devnode;   is_mouse      = val_mouse && !strcmp(val_mouse, "1") && devnode;   is_touchpad   = val_touchpad && !strcmp(val_touchpad, "1") && devnode;   if (!is_keyboard && !is_mouse && !is_touchpad)      goto end;   if (is_keyboard)   {      cb = udev_handle_keyboard;      devtype = "keyboard";   }   else if (is_touchpad)   {      cb = udev_handle_touchpad;      devtype = "touchpad";   }   else if (is_mouse)   {      cb = udev_handle_mouse;      devtype = "mouse";   }   if (!strcmp(action, "add"))   {      RARCH_LOG("[udev]: Hotplug add %s: %s./n", devtype, devnode);      add_device(udev, devnode, cb);   }   else if (!strcmp(action, "remove"))   {      RARCH_LOG("[udev]: Hotplug remove %s: %s./n", devtype, devnode);      udev_input_remove_device(udev, devnode);   }end:   udev_device_unref(dev);}

static void udev_input_handle_hotplug(udev_input_t *udev){   const char *devtype      = NULL;   const char *val_keyboard = NULL;   const char *val_mouse    = NULL;   const char *val_touchpad = NULL;   const char *action       = NULL;   const char *devnode      = NULL;   struct udev_device *dev  = udev_monitor_receive_device(udev->monitor);   if (!dev)      return;   val_keyboard  = udev_device_get_property_value(dev, "ID_INPUT_KEYBOARD");   val_mouse     = udev_device_get_property_value(dev, "ID_INPUT_MOUSE");   val_touchpad  = udev_device_get_property_value(dev, "ID_INPUT_TOUCHPAD");   action        = udev_device_get_action(dev);   devnode       = udev_device_get_devnode(dev);   if (val_keyboard && string_is_equal_fast(val_keyboard, "1", 1) && devnode)      devtype = "keyboard";   if (val_mouse && string_is_equal_fast(val_mouse, "1", 1) && devnode)      devtype = "mouse";   if (val_touchpad && string_is_equal_fast(val_touchpad, "1", 1) && devnode)      devtype = "touchpad";   if (!devtype)      goto end;   if (string_is_equal_fast(action, "add", 3))   {      device_handle_cb cb      = NULL;      if (string_is_equal_fast(devtype, "keyboard", 8))         cb = udev_handle_keyboard;      else if (string_is_equal_fast(devtype, "touchpad", 8))         cb = udev_handle_touchpad;      else if (string_is_equal_fast(devtype, "mouse", 5))         cb = udev_handle_mouse;      RARCH_LOG("[udev]: Hotplug add %s: %s./n", devtype, devnode);      udev_input_add_device(udev, devnode, cb);   }   else if (string_is_equal_fast(action, "remove", 6))   {      RARCH_LOG("[udev]: Hotplug remove %s: %s./n", devtype, devnode);      udev_input_remove_device(udev, devnode);   }end:   udev_device_unref(dev);}

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

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

boolUdevSubsystem::on_udev_data(GIOChannel* channel, GIOCondition condition){  if (condition == G_IO_OUT)  {    log_error("data can be written");  }  else if (condition == G_IO_PRI)  {    log_error("data can be read");  }  else if (condition == G_IO_ERR)  {    log_error("data error");  }  else if (condition != G_IO_IN)  {    log_error("unknown condition: " << condition);  }  else  {    log_info("trying to read data from udev");    log_info("trying to read data from udev monitor");    struct udev_device* device = udev_monitor_receive_device(m_monitor);    log_info("got data from udev monitor");    if (!device)    {      // seem to be normal, do we get this when the given device is filtered out?      log_debug("udev device couldn't be read: " << device);    }    else    {      const char* action = udev_device_get_action(device);      if (g_logger.get_log_level() >= Logger::kDebug)      {        print_info(device);      }      if (action && strcmp(action, "add") == 0)      {        m_process_match_cb(device);      }      udev_device_unref(device);    }  }  return true;}

void linux_udev_hotplug_poll(void){	struct udev_device* udev_dev;	usbi_mutex_static_lock(&linux_hotplug_lock);	do {		udev_dev = udev_monitor_receive_device(udev_monitor);		if (udev_dev) {			usbi_dbg("Handling hotplug event from hotplug_poll");			udev_hotplug_event(udev_dev);		}	} while (udev_dev);	usbi_mutex_static_unlock(&linux_hotplug_lock);}

static int manager_udev_fn(sd_event_source *source,			   int fd,			   uint32_t mask,			   void *data){	_cleanup_udev_device_ struct udev_device *d = NULL;	struct manager *m = data;	const char *action, *ifname;	unsigned int ifindex;	struct link *l;	d = udev_monitor_receive_device(m->udev_mon);	if (!d)		return 0;	ifindex = ifindex_from_udev_device(d);	if (!ifindex)		return 0;	l = manager_find_link(m, ifindex);	action = udev_device_get_action(d);	if (action && !strcmp(action, "remove")) {		if (l)			link_free(l);	} else if (l) {		ifname = udev_device_get_property_value(d, "INTERFACE");		if (action && !strcmp(action, "move")) {			if (ifname)				link_renamed(l, ifname);		}#ifdef RELY_UDEV		if (udev_device_has_tag(d, "miracle") && !lazy_managed)			link_set_managed(l, true);		else			link_set_managed(l, false);#else		if ((!interface_name || !strcmp(interface_name, ifname)) && !lazy_managed) {			link_set_managed(l, true);		} else {			log_debug("ignored device: %s", ifname);		}#endif	} else {		manager_add_udev_link(m, d);	}	return 0;}

void QDeviceDiscovery::handleUDevNotification(){    if (!m_udevMonitor)        return;    struct udev_device *dev;    QString devNode;    dev = udev_monitor_receive_device(m_udevMonitor);    if (!dev)        goto cleanup;    const char *action;    action = udev_device_get_action(dev);    if (!action)        goto cleanup;    const char *str;    str = udev_device_get_devnode(dev);    if (!str)        goto cleanup;    const char *subsystem;    devNode = QString::fromUtf8(str);    if (devNode.startsWith(QLatin1String(QT_EVDEV_DEVICE)))        subsystem = "input";    else if (devNode.startsWith(QLatin1String(QT_DRM_DEVICE)))        subsystem = "drm";    else goto cleanup;    // if we cannot determine a type, walk up the device tree    if (!checkDeviceType(dev)) {        // does not increase the refcount        dev = udev_device_get_parent_with_subsystem_devtype(dev, subsystem, 0);        if (!dev)            goto cleanup;        if (!checkDeviceType(dev))            goto cleanup;    }    if (qstrcmp(action, "add") == 0)        emit deviceDetected(devNode);    if (qstrcmp(action, "remove") == 0)        emit deviceRemoved(devNode);cleanup:    udev_device_unref(dev);}

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

bool CUDevProvider::PumpDriveChangeEvents(IStorageEventsCallback *callback){  bool changed = false;  fd_set readfds;  FD_ZERO(&readfds);  FD_SET(udev_monitor_get_fd(m_udevMon), &readfds);  // non-blocking, check the file descriptor for received data  struct timeval tv = {0};  int count = select(udev_monitor_get_fd(m_udevMon) + 1, &readfds, NULL, NULL, &tv);  if (count < 0)    return false;  if (FD_ISSET(udev_monitor_get_fd(m_udevMon), &readfds))  {		struct udev_device *dev = udev_monitor_receive_device(m_udevMon);    if (!dev)      return false;    const char *action  = udev_device_get_action(dev);    const char *devtype = udev_device_get_devtype(dev);    if (action)    {      const char *label = udev_device_get_property_value(dev, "ID_FS_LABEL");      const char *mountpoint = get_mountpoint(udev_device_get_devnode(dev));      if (!label)        label = URIUtils::GetFileName(mountpoint);      if (!strcmp(action, "add") && !strcmp(devtype, "partition"))      {        CLog::Log(LOGNOTICE, "UDev: Added %s", mountpoint);        if (callback)          callback->OnStorageAdded(label, mountpoint);        changed = true;      }      if (!strcmp(action, "remove") && !strcmp(devtype, "partition"))      {        CLog::Log(LOGNOTICE, "UDev: Removed %s", mountpoint);        if (callback)          callback->OnStorageSafelyRemoved(label);        changed = true;      }    }    udev_device_unref(dev);  }  return changed;}

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

static int udev_handle(int fd) {  struct udev_device *dev = udev_monitor_receive_device(udev_mon);  const char *action = udev_device_get_action(dev);  if (action != NULL) {    if (autoadd && strcmp("add", action) == 0) {      const char *devnode = udev_device_get_devnode(dev);      int id;      if (devnode != NULL && sscanf(devnode, "/dev/input/event%d", &id) == 1) {        evdev_create(devnode, defaultMapfile);      }    }    udev_device_unref(dev);  }  return LOOP_OK;}

int udev_handle_events(struct udev_handle *uh){	struct udev_device *device;	if (!uh || !uh->udev_ctx | !uh->udev_monitor)		return -1;	device = udev_monitor_receive_device(uh->udev_monitor);	if (device == NULL)	{		return -1;	}	usb_dongle_detect(device);	udev_device_unref(device);	return 0;}

static gboolean monitor_watch(GIOChannel *source, GIOCondition condition,							gpointer data){	struct udev_device *udevice;	udevice = udev_monitor_receive_device(monitor);	if (!udevice)		return TRUE;	if (!g_strcmp0(udev_device_get_action(udevice), "add"))		device_added(udevice);	udev_device_unref(udevice);	return TRUE;}

int l3_listen(struct l3_parity *par, bool daemon, struct l3_location *loc){	struct udev_device *udev_dev;	const char *parity_status;	char *err_msg;	int ret;again:	ret = select(par->fd + 1, &par->fdset, NULL, NULL, NULL);	/* Number of bits set is returned, must be >= 1 */	if (ret <= 0) {		return ret;	}	assert(FD_ISSET(par->fd, &par->fdset));	udev_dev = udev_monitor_receive_device(par->uevent_monitor);	if (!udev_dev)		return -1;	parity_status = udev_device_get_property_value(udev_dev, I915_L3_PARITY_UEVENT);	if (strncmp(parity_status, "1", 1))		goto again;	loc->slice = atoi(udev_device_get_property_value(udev_dev, "SLICE"));	loc->row = atoi(udev_device_get_property_value(udev_dev, "ROW"));	loc->bank = atoi(udev_device_get_property_value(udev_dev, "BANK"));	loc->subbank = atoi(udev_device_get_property_value(udev_dev, "SUBBANK"));	udev_device_unref(udev_dev);	asprintf(&err_msg, "Parity error detected on: %d,%d,%d,%d. "			"Try to run intel_l3_parity -r %d -b %d -s %d -w %d -d",			loc->slice, loc->row, loc->bank, loc->subbank,			loc->row, loc->bank, loc->subbank, loc->slice);	if (daemon) {		syslog(LOG_INFO, "%s/n", err_msg);		goto again;	}	fprintf(stderr, "%s/n", err_msg);	free(err_msg);	return 0;}

void UdevDeviceNotifier::socketActivated(){    static const char *keyboardDevice[] = {        "ID_INPUT_KEYBOARD",        "ID_INPUT_KEY"    };    static const char *pointerDevice[] = {        "ID_INPUT_MOUSE",        "ID_INPUT_TOUCHPAD",        "ID_INPUT_TABLET"    };    struct udev_device *dev = udev_monitor_receive_device(m_monitor);    if (!dev) {        return;    }    const char *action = udev_device_get_action(dev);    if (!action || qstrcmp(action, "add") != 0) {        udev_device_unref(dev);        return;    }    // Skip devices with empty name    if (!udev_device_get_property_value(dev, "NAME")) {        udev_device_unref(dev);        return;    }    for (unsigned i = 0; i < sizeof(keyboardDevice) / sizeof(keyboardDevice[0]); ++i) {        if (qstrcmp(udev_device_get_property_value(dev, keyboardDevice[i]), "1") == 0) {            Q_EMIT newKeyboardDevice();            break;        }    }    for (unsigned i = 0; i < sizeof(pointerDevice) / sizeof(pointerDevice[0]); ++i) {        if (qstrcmp(udev_device_get_property_value(dev, pointerDevice[i]), "1") == 0) {            Q_EMIT newPointerDevice();            break;        }    }    udev_device_unref(dev);}

static void udev_hotplug_event(void){	struct udev_device* udev_dev;	const char* udev_action;	const char* sys_name = NULL;	uint8_t busnum = 0, devaddr = 0;	int detached;	int r;	if (NULL == udev_monitor) {		return;	}	do {		udev_dev = udev_monitor_receive_device(udev_monitor);		if (!udev_dev) {			usbi_err(NULL, "failed to read data from udev monitor socket.");			return;		}		udev_action = udev_device_get_action(udev_dev);		if (!udev_action) {			break;		}		detached = !strncmp(udev_action, "remove", 6);		r = udev_device_info(NULL, detached, udev_dev, &busnum, &devaddr, &sys_name);		if (LIBUSB_SUCCESS != r) {			break;		}		usbi_dbg("udev hotplug event. action: %s.", udev_action);		if (strncmp(udev_action, "add", 3) == 0) {			linux_hotplug_enumerate(busnum, devaddr, sys_name);		} else if (detached) {			linux_hotplug_disconnected(busnum, devaddr, sys_name);		} else {			usbi_err(NULL, "ignoring udev action %s", udev_action);		}	} while (0);	udev_device_unref(udev_dev);}

static int manager_dispatch_link_udev(sd_event_source *source, int fd, uint32_t revents, void *userdata) {        Manager *m = userdata;        struct udev_monitor *monitor = m->udev_monitor;        struct udev_device *device;        int r;        device = udev_monitor_receive_device(monitor);        if (!device)                return -ENOMEM;        r = manager_process_link(m, device);        if (r < 0)                return r;        udev_device_unref(device);        return 0;}

rw_status_trw_udev_recv_device(rw_udev_handle_t *handle){  struct udev_device *dev;    dev = udev_monitor_receive_device(handle->mon);  if (dev) {    printf("Got Device/n");    printf("   Node: %s/n", udev_device_get_devnode(dev));    printf("   Subsystem: %s/n", udev_device_get_subsystem(dev));    printf("   Devtype: %s/n", udev_device_get_devtype(dev));        printf("   Action: %s/n", udev_device_get_action(dev));    udev_device_unref(dev);  }    return RW_STATUS_SUCCESS;}

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