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

cairo_drm_device_t *cairo_drm_device_default (void){    struct udev *udev;    struct udev_enumerate *e;    struct udev_list_entry *entry;    cairo_drm_device_t *dev;    /* optimistic atomic pointer read */    dev = _cairo_drm_default_device;    if (dev != NULL)	return dev;    udev = udev_new();    if (udev == NULL) {	_cairo_error_throw (CAIRO_STATUS_NO_MEMORY);	return (cairo_drm_device_t *) &_nil_device;    }    e = udev_enumerate_new (udev);    udev_enumerate_add_match_subsystem (e, "drm");    udev_enumerate_scan_devices (e);    udev_list_entry_foreach (entry, udev_enumerate_get_list_entry (e)) {	struct udev_device *device;	device =	    udev_device_new_from_syspath (udev,		    udev_list_entry_get_name (entry));	dev = cairo_drm_device_get (device);	udev_device_unref (device);	if (dev != NULL) {	    if (dev->fd == -1) { /* try again, we may find a usable card */		cairo_drm_device_destroy (dev);		dev = NULL;	    } else		break;	}    }    udev_enumerate_unref (e);    udev_unref (udev);    cairo_drm_device_destroy (dev); /* owned by _cairo_drm_default_device */    return dev;}

void Init(){  s_devnode_name_map.clear();  // During initialization we use udev to iterate over all /dev/input/event* devices.  // Note: the Linux kernel is currently limited to just 32 event devices. If this ever  //            changes, hopefully udev will take care of this.  udev* udev = udev_new();  _assert_msg_(PAD, udev != nullptr, "Couldn't initialize libudev.");  // List all input devices  udev_enumerate* enumerate = udev_enumerate_new(udev);  udev_enumerate_add_match_subsystem(enumerate, "input");  udev_enumerate_scan_devices(enumerate);  udev_list_entry* devices = udev_enumerate_get_list_entry(enumerate);  // Iterate over all input devices  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);    udev_device* dev = udev_device_new_from_syspath(udev, path);    const char* devnode = udev_device_get_devnode(dev);    // We only care about devices which we have read/write access to.    if (devnode && access(devnode, W_OK) == 0)    {      // Unfortunately udev gives us no way to filter out the non event device interfaces.      // So we open it and see if it works with evdev ioctls or not.      std::string name = GetName(devnode);      auto input = std::make_shared<evdevDevice>(devnode);      if (input->IsInteresting())      {        g_controller_interface.AddDevice(std::move(input));        s_devnode_name_map.insert(std::pair<std::string, std::string>(devnode, name));      }    }    udev_device_unref(dev);  }  udev_enumerate_unref(enumerate);  udev_unref(udev);  StartHotplugThread();}

bool QUdevService::isSubsystemAvailable(const char *subsystem){    bool available = false;    struct udev_enumerate *enumerate = 0;    if (context) {        if ((enumerate = udev_enumerate_new(context))            && (0 == udev_enumerate_add_match_subsystem(enumerate, subsystem))            && (0 == udev_enumerate_scan_devices(enumerate))) {            available = (0 != udev_enumerate_get_list_entry(enumerate));        }    }    if (enumerate)        udev_enumerate_unref(enumerate);    return available;}

/** * @brief Create a new net object * @param name The name of the underlying device (eth0, br1, etc) * @return A newly allocated net object, or NULL on failure * * This function creates a new net object based on @p name. * Only the most minimal lookups are performed at creation in order * to save memory. */Eeze_Net *eeze_net_new(const char *name){   const char *syspath = NULL;   const char *idx;   _udev_enumerate *en;   _udev_list_entry *devs, *cur;   _udev_device *device = NULL;   Eeze_Net *net;   net = eina_hash_find(eeze_nets, name);   if (net)     {        EINA_REFCOUNT_REF(net);        return net;     }   en = udev_enumerate_new(udev);   udev_enumerate_add_match_sysname(en, name);   udev_enumerate_add_match_subsystem(en, "net");   udev_enumerate_scan_devices(en);   devs = udev_enumerate_get_list_entry(en);   udev_list_entry_foreach(cur, devs)     {        const char *devname, *test;        devname = udev_list_entry_get_name(cur);        test = strrchr(devname, '/');        if (strcmp(++test, name)) continue;        device = _new_device(devname);        syspath = eina_stringshare_add(name);        break;     }   if (!device) return NULL;   net = calloc(1, sizeof(Eeze_Net));   if (!net) return NULL;   EINA_REFCOUNT_INIT(net);   net->device = device;   net->syspath = syspath;   net->name = eina_stringshare_add(name);   idx = udev_device_get_sysattr_value(net->device, "ifindex");   net->index = atoi(idx);   eina_hash_add(eeze_nets, name, net);   udev_enumerate_unref(en);   return net;}

/** Open the first DRM device matching the criteria */int drm_open_matching(const char *pci_glob, int flags, int *vendor_id, int *device_id){	struct udev *udev;	struct udev_enumerate *e;	struct udev_device *device, *parent;        struct udev_list_entry *entry;	const char *pci_id, *path;        char *tmp;	int fd;        *vendor_id = 0;        *device_id = 0;        	udev = udev_new();	if (udev == NULL) {		fprintf(stderr, "failed to initialize udev context/n");                return -1;		//abort();	}	fd = -1;	e = udev_enumerate_new(udev);	udev_enumerate_add_match_subsystem(e, "drm");        udev_enumerate_scan_devices(e);        udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {		path = udev_list_entry_get_name(entry);		device = udev_device_new_from_syspath(udev, path);		parent = udev_device_get_parent(device);		/* Filter out KMS output devices. */		if (strcmp(udev_device_get_subsystem(parent), "pci") != 0)			continue;		pci_id = udev_device_get_property_value(parent, "PCI_ID");		if (fnmatch(pci_glob, pci_id, 0) != 0)			continue;		fd = open(udev_device_get_devnode(device), O_RDWR);		if (fd < 0)			continue;		if ((flags & DRM_TEST_MASTER) && !is_master(fd)) {			close(fd);			fd = -1;			continue;		}		break;	}

int linux_udev_scan_devices(struct libusb_context *ctx){	struct udev_enumerate *enumerator;	struct udev_list_entry *devices, *entry;	struct udev_device *udev_dev;	const char *sys_name;	int r;	if (NULL == udev_ctx) {		udev_ctx = udev_new();		if (!udev_ctx) {			return LIBUSB_ERROR_OTHER;		}	}	enumerator = udev_enumerate_new(udev_ctx);	if (NULL == enumerator) {		usbi_err(ctx, "error creating udev enumerator");		return LIBUSB_ERROR_OTHER;	}	udev_enumerate_add_match_subsystem(enumerator, "usb");	udev_enumerate_scan_devices(enumerator);	devices = udev_enumerate_get_list_entry(enumerator);	udev_list_entry_foreach(entry, devices) {		const char *path = udev_list_entry_get_name(entry);		uint8_t busnum = 0, devaddr = 0;		udev_dev = udev_device_new_from_syspath(udev_ctx, path);		r = udev_device_info(ctx, 0, udev_dev, &busnum, &devaddr, &sys_name);		if (r) {			udev_device_unref(udev_dev);			continue;		}		linux_enumerate_device(ctx, busnum, devaddr, sys_name);		udev_device_unref(udev_dev);	}	udev_enumerate_unref(enumerator);        return LIBUSB_SUCCESS;}

int manager_udev_enumerate_links(Manager *m) {        struct udev_list_entry *item = NULL, *first = NULL;        struct udev_enumerate *e;        int r;        assert(m);        e = udev_enumerate_new(m->udev);        if (!e) {                r = -ENOMEM;                goto finish;        }        r = udev_enumerate_add_match_subsystem(e, "net");        if (r < 0)                goto finish;        r = udev_enumerate_scan_devices(e);        if (r < 0)                goto finish;        first = udev_enumerate_get_list_entry(e);        udev_list_entry_foreach(item, first) {                struct udev_device *d;                int k;                d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));                if (!d) {                        r = -ENOMEM;                        goto finish;                }                k = manager_process_link(m, d);                udev_device_unref(d);                if (k < 0)                        r = k;        }finish:        if (e)                udev_enumerate_unref(e);        return r;}

eErrorCode GetStorageDevicePaths(std::vector<String>& DevicePaths, std::vector<String>& SysDevicePaths){    struct udev *udevObject;    struct udev_enumerate *enumerate;    struct udev_list_entry *devices, *udevListEntry;    struct udev_device *udevDevice;    //! Create the udev object    udevObject = udev_new();    if (nullptr == udevObject)    {        //! ERROR: Can't create udev        return(eErrorCode::Memory);    }    //! Create a list of the devices in the 'block' subsystem    enumerate = udev_enumerate_new(udevObject);    udev_enumerate_add_match_subsystem(enumerate, "block");    udev_enumerate_scan_devices(enumerate);    devices = udev_enumerate_get_list_entry(enumerate);    udev_list_entry_foreach(udevListEntry, devices)    {        const char *devicePath;        devicePath = udev_list_entry_get_name(udevListEntry);        udevDevice = udev_device_new_from_syspath(udevObject, devicePath);        String udeviceNode = udev_device_get_devnode(udevDevice);        if (true == IsStorageDisk(udevDevice))        {            DevicePaths.push_back(udeviceNode);            SysDevicePaths.push_back(devicePath);        }        udev_device_unref(udevDevice);    }    //! Free the enumerator object    udev_enumerate_unref(enumerate);    udev_unref(udevObject);    return(eErrorCode::None);}

	Array<GamepadDeviceInfo> LinuxGetAttachedJoysticks() {		Array<GamepadDeviceInfo> deviceInfoArray;		udev *udev_context;		udev_enumerate *enumerate;		udev_list_entry *devices, *dev_list_entry;		udev_device *dev;		udev_context = udev_new();		if (!udev_context) {			// TODO: Throw error			return deviceInfoArray;		}		enumerate = udev_enumerate_new(udev_context);		udev_enumerate_add_match_subsystem(enumerate, "input");		udev_enumerate_scan_devices(enumerate);		devices = udev_enumerate_get_list_entry(enumerate);		udev_list_entry_foreach(dev_list_entry, devices) {			const char *path = NULL, *devnode = NULL;			path = udev_list_entry_get_name(dev_list_entry);			dev = udev_device_new_from_syspath(udev_context, path);			devnode = udev_device_get_devnode(dev);			dev = udev_device_get_parent_with_subsystem_devtype(				dev, "usb", "usb_device");			if (devnode && dev) {				if (strstr(devnode, "js")) {					GamepadDeviceInfo deviceInfo;					deviceInfo.mProductName =						udev_device_get_sysattr_value(dev, "product");					deviceInfo.mManufacturer =						udev_device_get_sysattr_value(dev, "manufacturer");					deviceInfo.mGuid =						String(udev_device_get_sysattr_value(dev, "product")) +						String(udev_device_get_sysattr_value(dev, "idVendor")) +						String(udev_device_get_sysattr_value(dev, "serial"));					deviceInfo.mDeviceHandle =						open(devnode, O_RDONLY | O_NONBLOCK);					deviceInfoArray.Append(deviceInfo);				}			}			udev_device_unref(dev);		}		udev_enumerate_unref(enumerate);		udev_unref(udev_context);		return deviceInfoArray;	}

char *v4l2cpi_udev_get_serial (const char* devfile){	struct udev *udev;	struct udev_enumerate *enumerate;	struct udev_list_entry *devices, *dev_list_entry;	struct udev_device *dev;	char *ret = NULL;		udev = udev_new ();	if (!udev)		return NULL;		enumerate = udev_enumerate_new (udev);	udev_enumerate_add_match_subsystem (enumerate, "video4linux");	udev_enumerate_scan_devices (enumerate);	devices = udev_enumerate_get_list_entry (enumerate);	udev_list_entry_foreach (dev_list_entry, devices){		const char *path;				path = udev_list_entry_get_name (dev_list_entry);		dev = udev_device_new_from_syspath (udev, path);		if (!strcmp (udev_device_get_devnode (dev), devfile)){			dev = udev_device_get_parent_with_subsystem_devtype (dev, "usb", "usb_device");			if (dev){				const char *serial;								serial = udev_device_get_sysattr_value(dev, "serial");				if (serial){					ret = malloc (strlen (serial)+1);					strcpy (ret, serial);				}				udev_device_unref (dev);			}		}	}	/* Free the enumerator object */	udev_enumerate_unref(enumerate);	udev_unref(udev);	return ret;}

// List of devices: http://www.ideasonboard.org/uvc/ // How to use libudev: http://www.signal11.us/oss/udev/std::vector<LinuxCaptureDevice> VideoCaptureV4L2::getDeviceList() {  std::vector<LinuxCaptureDevice> found_devices;  struct udev* udev;  struct udev_enumerate* enumerate;  struct udev_list_entry* devices;  struct udev_list_entry* dev_list_entry;  struct udev_device* dev;  udev = udev_new();  if(!udev) {    printf("ERROR: cannot udev_new()/n");    return found_devices;  }  enumerate = udev_enumerate_new(udev);  udev_enumerate_add_match_subsystem(enumerate, "video4linux");  udev_enumerate_scan_devices(enumerate);  devices = udev_enumerate_get_list_entry(enumerate);  udev_list_entry_foreach(dev_list_entry, devices) {    LinuxCaptureDevice linux_device;    const char* path = udev_list_entry_get_name(dev_list_entry);    dev = udev_device_new_from_syspath(udev, path);    const char* devpath = udev_device_get_devnode(dev);    linux_device.path.assign(devpath, strlen(devpath));        dev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device");    if(!dev) {      printf("VERBOSE: cannot find related usb device./n");      found_devices.push_back(linux_device);      continue;    }    const char* id_vendor = udev_device_get_sysattr_value(dev, "idVendor");    linux_device.id_vendor.assign(id_vendor, strlen(id_vendor));    const char* id_product = udev_device_get_sysattr_value(dev, "idProduct");    linux_device.id_product.assign(id_product, strlen(id_product));    found_devices.push_back(linux_device);  }

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

intmain(int argc, char **argv){	int blight, connector_id;	const char *default_seat = "seat0";	const char *path, *device_seat;	struct udev *udev;	struct udev_enumerate *e;	struct udev_list_entry *entry;	struct udev_device *device, *drm_device;	if (argc < 3) {		printf("Please add connector_id and brightness values from 0-255/n");		return 1;	}	connector_id = atoi(argv[1]);	blight = atoi(argv[2]);	udev = udev_new();	if (udev == NULL) {		printf("failed to initialize udev context/n");		return 1;	}	e = udev_enumerate_new(udev);	udev_enumerate_add_match_subsystem(e, "drm");	udev_enumerate_add_match_sysname(e, "card[0-9]*");	udev_enumerate_scan_devices(e);	drm_device = NULL;	udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {		path = udev_list_entry_get_name(entry);		device = udev_device_new_from_syspath(udev, path);		device_seat =			udev_device_get_property_value(device, "ID_SEAT");		if (!device_seat)			device_seat = default_seat;		drm_device = device;		break;	}

int manager_udev_enumerate_links(Manager *m) {        _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;        struct udev_list_entry *item = NULL, *first = NULL;        int r;        assert(m);        e = udev_enumerate_new(m->udev);        if (!e)                return -ENOMEM;        r = udev_enumerate_add_match_subsystem(e, "net");        if (r < 0)                return r;        /* udev does not initialize devices inside containers,         * so we rely on them being already initialized before         * entering the container */        if (detect_container(NULL) <= 0) {                r = udev_enumerate_add_match_is_initialized(e);                if (r < 0)                        return r;        }        r = udev_enumerate_scan_devices(e);        if (r < 0)                return r;        first = udev_enumerate_get_list_entry(e);        udev_list_entry_foreach(item, first) {                _cleanup_udev_device_unref_ struct udev_device *d = NULL;                int k;                d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));                if (!d)                        return -ENOMEM;                k = manager_process_link(m, d);                if (k < 0)                        r = k;        }

void gpio_switch_list_for_each(gpio_switch_list_callback callback, void *arg){	struct udev *udev;	struct udev_enumerate *enumerate;	struct udev_list_entry *dl;	struct udev_list_entry *dev_list_entry;	if (!callback)		return;	udev = udev_new();	assert(udev != NULL);	enumerate = udev_enumerate_new(udev);	udev_enumerate_add_match_subsystem(enumerate, "input");	udev_enumerate_scan_devices(enumerate);	dl = udev_enumerate_get_list_entry(enumerate);	udev_list_entry_foreach(dev_list_entry, dl) {		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);		char *ioctl_name;		if (devnode == NULL)			continue;		ioctl_name = sys_input_get_device_name(devnode);		if (ioctl_name == NULL)			continue;		if (callback(devnode, ioctl_name, arg)) {			free(ioctl_name);			break;		}		free(ioctl_name);	}	udev_enumerate_unref(enumerate);	udev_unref(udev);}

void MImHwKeyboardTrackerPrivate::detectEvdev(){    // Use udev to enumerate all input devices, using evdev on each device to    // find the first device offering a SW_TABLET_MODE switch. If found, this    // switch is used to determine keyboard presence.    struct udev_list_entry *device;    struct udev_list_entry *devices;    struct udev *udev = udev_new();    if (!udev)        return;    struct udev_enumerate *enumerate = udev_enumerate_new(udev);    if (!enumerate) {        udev_unref(udev);        return;    }    udev_enumerate_add_match_subsystem(enumerate, "input");    udev_enumerate_add_match_property(enumerate, "ID_INPUT", "1");    udev_enumerate_scan_devices(enumerate);    devices = udev_enumerate_get_list_entry(enumerate);    udev_list_entry_foreach(device, devices) {        const char *syspath = udev_list_entry_get_name(device);        struct udev_device *udev_device =            udev_device_new_from_syspath(udev, syspath);        const char *device = udev_device_get_devnode(udev_device);        if (device)            tryEvdevDevice(device);        udev_device_unref(udev_device);        if (present)            break;    }    udev_enumerate_unref(enumerate);    udev_unref(udev);}

intrw_netlink_get_pci_addr(const char *ifname, rw_pci_address_t *pci_addr){  struct udev *udev = NULL;  struct udev_enumerate *enumerate = NULL;  struct udev_list_entry *devices, *dev_list_entry;  int ret = -1;    udev = udev_new();  if (!udev) {    ret = -1;    goto ret;  }  enumerate = udev_enumerate_new(udev);  udev_enumerate_add_match_subsystem(enumerate, "net");  udev_enumerate_add_match_sysname(enumerate, ifname);  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){      break;    }  }ret:  if (enumerate){    udev_enumerate_unref(enumerate);  }  if (udev){    udev_unref(udev);  }  return ret;}

static void udev_enum(){    struct udev_enumerate* enumerator = udev_enumerate_new(udev);    udev_enumerate_add_match_subsystem(enumerator, "usb");    udev_enumerate_add_match_sysattr(enumerator, "idVendor", V_CORSAIR_STR);    udev_enumerate_scan_devices(enumerator);    struct udev_list_entry* devices, *dev_list_entry;    devices = udev_enumerate_get_list_entry(enumerator);    udev_list_entry_foreach(dev_list_entry, devices){        const char* path = udev_list_entry_get_name(dev_list_entry);        if(!path)            continue;        struct udev_device* dev = udev_device_new_from_syspath(udev, path);        if(!dev)            continue;        // If the device matches a recognized device ID, open it        if(usb_add_device(dev))            // Release device if not            udev_device_unref(dev);    }    udev_enumerate_unref(enumerator);}

struct icd_drm_device *icd_drm_enumerate(const struct icd_instance *instance,                                         int vendor_id){    struct icd_drm_device *devices = NULL;    struct udev *udev;    struct udev_enumerate *e;    struct udev_list_entry *entry;    udev = udev_new();    if (udev == NULL) {        icd_instance_log(instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,                         0, VK_NULL_HANDLE,     /* obj_type, object */                         0, 0,                  /* location, msg_code */                         "failed to initialize udev context");        return NULL;    }    e = udev_enumerate_new(udev);    if (e == NULL) {        icd_instance_log(instance, VK_DEBUG_REPORT_ERROR_BIT_EXT,                         0, VK_NULL_HANDLE,     /* obj_type, object */                         0, 0,                  /* location, msg_code */                         "failed to initialize udev enumerate context");        udev_unref(udev);        return NULL;    }    /* we are interested in DRM minors */    udev_enumerate_add_match_subsystem(e, "drm");    udev_enumerate_add_match_property(e, "DEVTYPE", "drm_minor");    udev_enumerate_scan_devices(e);    udev_list_entry_foreach(entry, udev_enumerate_get_list_entry(e)) {        devices = probe_syspath(instance, devices, udev,                udev_list_entry_get_name(entry), vendor_id);    }

static char *get_leds_syspath_prefix(struct udev_device *udevice){	struct udev_list_entry *dev_list_entry;	struct udev_enumerate *enumerate;	struct udev_device *hid_parent;	const char *syspath;	char *syspath_prefix;	hid_parent = udev_device_get_parent_with_subsystem_devtype(udevice,								"hid", NULL);	enumerate = udev_enumerate_new(udev_device_get_udev(udevice));	udev_enumerate_add_match_parent(enumerate, hid_parent);	udev_enumerate_add_match_subsystem(enumerate, "leds");	udev_enumerate_scan_devices(enumerate);	dev_list_entry = udev_enumerate_get_list_entry(enumerate);	if (!dev_list_entry) {		syspath_prefix = NULL;		goto out;	}	syspath = udev_list_entry_get_name(dev_list_entry);	/*	 * All the sysfs paths of the LEDs have the same structure, just the	 * number changes, so strip it and store only the common prefix.	 *	 * Subtracting 1 here means assuming that the LED number is a single	 * digit, this is safe as the kernel driver only exposes 4 LEDs.	 */	syspath_prefix = strndup(syspath, strlen(syspath) - 1);out:	udev_enumerate_unref(enumerate);	return syspath_prefix;}

udevGetDevices(struct udev *udev, virUdevStatus status){    struct udev_enumerate *enumerate;    /* Create a new enumeration to create a list */    enumerate = udev_enumerate_new(udev);    if (!enumerate)        return NULL;    /* Enumerate all network subsystem devices */    udev_enumerate_add_match_subsystem(enumerate, "net");    /* Ignore devices that are part of a bridge */    udev_enumerate_add_nomatch_sysattr(enumerate, "brport/state", NULL);    /* State of the device */    switch (status) {        case VIR_UDEV_IFACE_ACTIVE:            udev_enumerate_add_match_sysattr(enumerate, "operstate", "up");            break;        case VIR_UDEV_IFACE_INACTIVE:            udev_enumerate_add_match_sysattr(enumerate, "operstate", "down");            break;        case VIR_UDEV_IFACE_ALL:            break;    }    /* We don't want to see the TUN devices that QEMU creates for other guests     * running on this machine. By saying nomatch NULL, we just are getting     * devices without the tun_flags sysattr.     */    udev_enumerate_add_nomatch_sysattr(enumerate, "tun_flags", NULL);    return enumerate;}

void udev_init(bool autoload, char* mapfile) {  udev = udev_new();  if (!udev) {    fprintf(stderr, "Can't create udev/n");    exit(1);  }  autoadd = autoload;  if (autoload) {    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) {        evdev_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);  defaultMapfile = mapfile;  int udev_fd = udev_monitor_get_fd(udev_mon);  loop_add_fd(udev_fd, &udev_handle, POLLIN);}

voidmount_plugged_devices (struct udev *udev){        const char *path;    const char *dev_node;    struct udev_enumerate *udev_enum;    struct udev_list_entry *devices;    struct udev_list_entry *entry;    struct udev_device *dev;    udev_enum = udev_enumerate_new(udev);    udev_enumerate_add_match_subsystem(udev_enum, "block");    udev_enumerate_scan_devices(udev_enum);    devices = udev_enumerate_get_list_entry(udev_enum);    udev_list_entry_foreach(entry, devices) {        path = udev_list_entry_get_name(entry);        dev = udev_device_new_from_syspath(udev, path);        dev_node = udev_device_get_devnode(dev);        if (!device_is_mounted((char *)dev_node))            device_mount(dev);    }

void TeensyControls_find_new_usb_devices(void){	fd_set fds;	struct timeval tv;	struct udev_device *dev;	const char *name, *action;	static unsigned int count=0, first=1;	struct udev_enumerate *enumerate;	struct udev_list_entry *devices, *dev_list_entry;	const char *path;	int r;	if (first) {		// set up monitoring		printf("TeensyControls_usb_init: set up udev monitoring/n");		mon = udev_monitor_new_from_netlink(udev, "udev");		udev_monitor_filter_add_match_subsystem_devtype(mon, "hidraw", NULL);		udev_monitor_enable_receiving(mon);		monfd = udev_monitor_get_fd(mon);		// enumerate all currently attached devices		printf("TeensyControls_usb_init: udev enumerate devices/n");		enumerate = udev_enumerate_new(udev);		udev_enumerate_add_match_subsystem(enumerate, "hidraw");		udev_enumerate_scan_devices(enumerate);		devices = udev_enumerate_get_list_entry(enumerate);		udev_list_entry_foreach(dev_list_entry, devices) {			path = udev_list_entry_get_name(dev_list_entry);			//printf("path: %s/n", path);			dev = udev_device_new_from_syspath(udev, path);			if (dev) {				new_usb_device(dev);				udev_device_unref(dev);			}		}		udev_enumerate_unref(enumerate);		first = 0;	}

static intget_usbinfo(int bus, int dev, usbinfo_t *ui){  struct udev_enumerate *enumerate;  struct udev_list_entry *devices, *dev_list_entry;  struct udev_device *udev_dev;  char bus_str[16], dev_str[16];  int vendor, product;  enumerate = udev_enumerate_new(udev_handle);  if (!enumerate) {    xd_log(LOG_ERR, "Can't create enumeration");    return -ENOMEM;  }  snprintf(bus_str, sizeof(bus_str), "%d", bus);  snprintf(dev_str, sizeof(dev_str), "%d", dev);  udev_enumerate_add_match_subsystem(enumerate, "usb");  udev_enumerate_add_match_sysattr(enumerate, "busnum", bus_str);  udev_enumerate_add_match_sysattr(enumerate, "devnum", dev_str);  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);    udev_dev = udev_device_new_from_syspath(udev_handle, path);    sscanf(udev_device_get_sysattr_value(udev_dev, "idVendor"), "%x", &vendor);    sscanf(udev_device_get_sysattr_value(udev_dev, "idProduct"), "%x", &product);    udev_device_unref(udev_dev);    udev_enumerate_unref(enumerate);    return usbowls_build_usbinfo(bus, dev, vendor, product, ui);  }  udev_enumerate_unref(enumerate);  return -ENOENT;}

static int smart_read (void){  struct udev *handle_udev;  struct udev_enumerate *enumerate;  struct udev_list_entry *devices, *dev_list_entry;  struct udev_device *dev;  /* Use udev to get a list of disks */  handle_udev = udev_new();  if (!handle_udev)  {    ERROR ("smart plugin: unable to initialize udev.");    return (-1);  }   INFO ("smart plugin: udev initialized.");    enumerate = udev_enumerate_new (handle_udev);  udev_enumerate_add_match_subsystem (enumerate, "block");  udev_enumerate_add_match_property (enumerate, "DEVTYPE", "disk");  udev_enumerate_scan_devices (enumerate);  devices = udev_enumerate_get_list_entry (enumerate);  udev_list_entry_foreach (dev_list_entry, devices)  {    const char *path, *devpath;    path = udev_list_entry_get_name (dev_list_entry);    dev = udev_device_new_from_syspath (handle_udev, path);    devpath = udev_device_get_devnode (dev);    /* Query status with libatasmart */    smart_handle_disk (devpath);  }  udev_enumerate_unref (enumerate);  udev_unref (handle_udev);  return (0);} /* int smart_read */

static void scan_devices(context_t *ctx){    struct udev *udev;    struct udev_enumerate *enm;    struct udev_list_entry *list, *entry;    struct udev_device *dev;    const char *syspath;    if (!ctx || !(udev = ctx->udev))        return;    enm = udev_enumerate_new(udev);    udev_enumerate_add_match_subsystem(enm, "input");    udev_enumerate_scan_devices(enm);    list = udev_enumerate_get_list_entry(enm);    udev_list_entry_foreach(entry, list) {        syspath = udev_list_entry_get_name(entry);        if ((dev = udev_device_new_from_syspath(udev, syspath))) {            handle_device(ctx, dev);            udev_device_unref(dev);        }    }

static void manager_read_links(struct manager *m){	_cleanup_udev_enumerate_ struct udev_enumerate *e = NULL;	struct udev_list_entry *l;	struct udev_device *d;	int r;	e = udev_enumerate_new(m->udev);	if (!e)		goto error;	r = udev_enumerate_add_match_subsystem(e, "net");	if (r < 0)		goto error;	r = udev_enumerate_add_match_property(e, "DEVTYPE", "wlan");	if (r < 0)		goto error;	r = udev_enumerate_add_match_is_initialized(e);	if (r < 0)		goto error;	r = udev_enumerate_scan_devices(e);	if (r < 0)		goto error;	udev_list_entry_foreach(l, udev_enumerate_get_list_entry(e)) {		d = udev_device_new_from_syspath(m->udev,						 udev_list_entry_get_name(l));		if (!d)			goto error;		manager_add_udev_link(m, d);		udev_device_unref(d);	}

int manager_udev_enumerate_links(Manager *m) {        _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;        struct udev_list_entry *item = NULL, *first = NULL;        int r;        assert(m);        e = udev_enumerate_new(m->udev);        if (!e)                return -ENOMEM;        r = udev_enumerate_add_match_subsystem(e, "net");        if (r < 0)                return r;        r = udev_enumerate_add_match_is_initialized(e);        if (r < 0)                return r;        r = udev_enumerate_scan_devices(e);        if (r < 0)                return r;        first = udev_enumerate_get_list_entry(e);        udev_list_entry_foreach(item, first) {                _cleanup_udev_device_unref_ struct udev_device *d = NULL;                int k;                d = udev_device_new_from_syspath(m->udev, udev_list_entry_get_name(item));                if (!d)                        return -ENOMEM;                k = manager_process_link(m, d);                if (k < 0)                        r = k;        }

struct hid_device_info  HID_API_EXPORT *hid_enumerate(unsigned short vendor_id, unsigned short product_id){	struct udev *udev;	struct udev_enumerate *enumerate;	struct udev_list_entry *devices, *dev_list_entry;		struct hid_device_info *root = NULL; // return object	struct hid_device_info *cur_dev = NULL;		setlocale(LC_ALL,"");	/* Create the udev object */	udev = udev_new();	if (!udev) {		printf("Can't create udev/n");		return NULL;	}	/* Create a list of the devices in the 'hidraw' subsystem. */	enumerate = udev_enumerate_new(udev);	udev_enumerate_add_match_subsystem(enumerate, "hidraw");	udev_enumerate_scan_devices(enumerate);	devices = udev_enumerate_get_list_entry(enumerate);	/* For each item, see if it matches the vid/pid, and if so	   create a udev_device record for it */	udev_list_entry_foreach(dev_list_entry, devices) {		const char *sysfs_path;		const char *dev_path;		const char *str;		struct udev_device *hid_dev; // The device's HID udev node.		struct udev_device *dev; // The actual hardware device.		struct udev_device *intf_dev; // The device's interface (in the USB sense).		unsigned short dev_vid;		unsigned short dev_pid;				/* Get the filename of the /sys entry for the device		   and create a udev_device object (dev) representing it */		sysfs_path = udev_list_entry_get_name(dev_list_entry);		hid_dev = udev_device_new_from_syspath(udev, sysfs_path);		dev_path = udev_device_get_devnode(hid_dev);				/* The device pointed to by hid_dev contains information about		   the hidraw device. In order to get information about the		   USB device, get the parent device with the		   subsystem/devtype pair of "usb"/"usb_device". This will		   be several levels up the tree, but the function will find		   it.*/		dev = udev_device_get_parent_with_subsystem_devtype(		       hid_dev,		       "usb",		       "usb_device");		if (!dev) {			/* Unable to find parent usb device. */			goto next;		}		/* Get the VID/PID of the device */		str = udev_device_get_sysattr_value(dev,"idVendor");		dev_vid = (str)? strtol(str, NULL, 16): 0x0;		str = udev_device_get_sysattr_value(dev, "idProduct");		dev_pid = (str)? strtol(str, NULL, 16): 0x0;		/* Check the VID/PID against the arguments */		if ((vendor_id == 0x0 && product_id == 0x0) ||		    (vendor_id == dev_vid && product_id == dev_pid)) {			struct hid_device_info *tmp;			size_t len;		    	/* VID/PID match. Create the record. */			tmp = malloc(sizeof(struct hid_device_info));			if (cur_dev) {				cur_dev->next = tmp;			}			else {				root = tmp;			}			cur_dev = tmp;						/* Fill out the record */			cur_dev->next = NULL;			str = dev_path;			if (str) {				len = strlen(str);				cur_dev->path = calloc(len+1, sizeof(char));				strncpy(cur_dev->path, str, len+1);				cur_dev->path[len] = '/0';			}			else				cur_dev->path = NULL;						/* Serial Number */			cur_dev->serial_number				= copy_udev_string(dev, "serial");			/* Manufacturer and Product strings */			cur_dev->manufacturer_string				= copy_udev_string(dev, "manufacturer");			cur_dev->product_string				= copy_udev_string(dev, "product");			//.........这里部分代码省略.........