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

static int manager_enumerate_devices(Manager *m) {        struct udev_list_entry *item = NULL, *first = NULL;        _cleanup_udev_enumerate_unref_ struct udev_enumerate *e = NULL;        int r;        assert(m);        /* Loads devices from udev and creates seats for them as         * necessary */        e = udev_enumerate_new(m->udev);        if (!e)                return -ENOMEM;        r = udev_enumerate_add_match_tag(e, "master-of-seat");        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_seat_device(m, d);                if (k < 0)                        r = k;        }

void udev_node_add(struct udev_device *dev, bool apply,                   mode_t mode, uid_t uid, gid_t gid,                   struct udev_list *seclabel_list) {        char filename[UTIL_PATH_SIZE];        struct udev_list_entry *list_entry;        log_debug("handling device node '%s', devnum=%s, mode=%#o, uid=%d, gid=%d",                  udev_device_get_devnode(dev), udev_device_get_id_filename(dev), mode, uid, gid);        if (node_permissions_apply(dev, apply, mode, uid, gid, seclabel_list) < 0)                return;        /* always add /dev/{block,char}/$major:$minor */        snprintf(filename, sizeof(filename), "/dev/%s/%u:%u",                 streq(udev_device_get_subsystem(dev), "block") ? "block" : "char",                 major(udev_device_get_devnum(dev)), minor(udev_device_get_devnum(dev)));        node_symlink(dev, udev_device_get_devnode(dev), filename);        /* create/update symlinks, add symlinks to name index */        udev_list_entry_foreach(list_entry, udev_device_get_devlinks_list_entry(dev))                        link_update(dev, udev_list_entry_get_name(list_entry), true);}

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

static bool open_devices(udev_input_t *udev, const char *type, device_handle_cb cb){   struct udev_list_entry     *devs = NULL;   struct udev_list_entry     *item = NULL;   struct udev_enumerate *enumerate = udev_enumerate_new(udev->udev);   if (!enumerate)      return false;   udev_enumerate_add_match_property(enumerate, type, "1");   udev_enumerate_scan_devices(enumerate);   devs = udev_enumerate_get_list_entry(enumerate);   for (item = devs; item; item = udev_list_entry_get_next(item))   {      const char *name        = udev_list_entry_get_name(item);      /* Get the filename of the /sys entry for the device       * and create a udev_device object (dev) representing it. */      struct udev_device *dev = udev_device_new_from_syspath(udev->udev, name);      const char *devnode     = udev_device_get_devnode(dev);      if (devnode)      {         int fd = open(devnode, O_RDONLY | O_NONBLOCK);         (void)fd;         RARCH_LOG("[udev] Adding device %s as type %s./n", devnode, type);         if (!add_device(udev, devnode, cb))            RARCH_ERR("[udev] Failed to open device: %s (%s)./n", devnode, strerror(errno));      }      udev_device_unref(dev);   }   udev_enumerate_unref(enumerate);   return true;}

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

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

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

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 */

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

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

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

static int usb_dongle_probe_print_list(struct udev_enumerate *enumerate){	struct udev_list_entry *list_entry;	unsigned int vid, pid;	int ret = -1;	udev_list_entry_foreach(list_entry, udev_enumerate_get_list_entry(enumerate)) {		struct udev_device *device;		device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerate),				udev_list_entry_get_name(list_entry));		if (device != NULL) {			mylog_info("device: '%s' (%s)/n",					udev_device_get_syspath(device),					udev_device_get_subsystem(device));			get_vid_pid(device, &vid, &pid);			ret = wlan_driver_match(vid, pid, wlan_driver_add_callback);			udev_device_unref(device);			if (!ret)				break;		}	}	return ret;}

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

/** * Probes and initializes. */static int Open (vlc_object_t *obj, const struct subsys *subsys){    services_discovery_t *sd = (services_discovery_t *)obj;    services_discovery_sys_t *p_sys = malloc (sizeof (*p_sys));    if (p_sys == NULL)        return VLC_ENOMEM;    sd->description = vlc_gettext(subsys->description);    sd->p_sys = p_sys;    p_sys->subsys = subsys;    p_sys->root = NULL;    struct udev_monitor *mon = NULL;    struct udev *udev = udev_new ();    if (udev == NULL)        goto error;    mon = udev_monitor_new_from_netlink (udev, "udev");    if (mon == NULL     || udev_monitor_filter_add_match_subsystem_devtype (mon, subsys->name,                                                         NULL))        goto error;    p_sys->monitor = mon;    /* Enumerate existing devices */    struct udev_enumerate *devenum = udev_enumerate_new (udev);    if (devenum == NULL)        goto error;    if (udev_enumerate_add_match_subsystem (devenum, subsys->name))    {        udev_enumerate_unref (devenum);        goto error;    }    udev_monitor_enable_receiving (mon);    /* Note that we enumerate _after_ monitoring is enabled so that we do not     * loose device events occuring while we are enumerating. We could still     * loose events if the Netlink socket receive buffer overflows. */    udev_enumerate_scan_devices (devenum);    struct udev_list_entry *devlist = udev_enumerate_get_list_entry (devenum);    struct udev_list_entry *deventry;    udev_list_entry_foreach (deventry, devlist)    {        const char *path = udev_list_entry_get_name (deventry);        struct udev_device *dev = udev_device_new_from_syspath (udev, path);        AddDevice (sd, dev);        udev_device_unref (dev);    }    udev_enumerate_unref (devenum);    if (vlc_clone (&p_sys->thread, Run, sd, VLC_THREAD_PRIORITY_LOW))    {   /* Fallback without thread */        udev_monitor_unref (mon);        udev_unref (udev);        p_sys->monitor = NULL;    }    return VLC_SUCCESS;error:    if (mon != NULL)        udev_monitor_unref (mon);    if (udev != NULL)        udev_unref (udev);    free (p_sys);    return VLC_EGENERIC;}

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");			//.........这里部分代码省略.........

int main (void){	struct udev *udev;	struct udev_enumerate *enumerate;	struct udev_list_entry *devices, *dev_list_entry;	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);	}	/* This section sets up a monitor which will report events when	   devices attached to the system change.  Events include "add",	   "remove", "change", "online", and "offline".	   This section sets up and starts the monitoring. Events are	   polled for (and delivered) later in the file.	   It is important that the monitor be set up before the call to	   udev_enumerate_scan_devices() so that events (and devices) are	   not missed.  For example, if enumeration happened first, there	   would be no event generated for a device which was attached after	   enumeration but before monitoring began.	   Note that a filter is added so that we only get events for	   "hidraw" devices. */	/* Set up a monitor to monitor hidraw devices */	mon = udev_monitor_new_from_netlink(udev, "udev");//	udev_monitor_filter_add_match_subsystem_devtype(mon, "hidraw", NULL);	udev_monitor_filter_add_match_subsystem_devtype(mon, "block", NULL);	udev_monitor_enable_receiving(mon);	/* Get the file descriptor (fd) for the monitor.	   This fd will get passed to select() */	fd = udev_monitor_get_fd(mon);	/* Create a list of the devices in the 'hidraw' subsystem. */	enumerate = udev_enumerate_new(udev);//	udev_enumerate_add_match_subsystem(enumerate, "hidraw");	udev_enumerate_add_match_subsystem(enumerate, "block");	udev_enumerate_scan_devices(enumerate);	devices = udev_enumerate_get_list_entry(enumerate);	/* For each item enumerated, print out its information.	   udev_list_entry_foreach is a macro which expands to	   a loop. The loop will be executed for each member in	   devices, setting dev_list_entry to a list entry	   which contains the device's path in /sys. */	udev_list_entry_foreach(dev_list_entry, devices) {		const char *path;		/* Get the filename of the /sys entry for the device		   and create a udev_device object (dev) representing it */		path = udev_list_entry_get_name(dev_list_entry);		dev = udev_device_new_from_syspath(udev, path);		/* usb_device_get_devnode() returns the path to the device node		   itself in /dev. */		printf("Device Node Path: %s/n", udev_device_get_devnode(dev));#if 0		/* The device pointed to by 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(		       dev,		       "usb",		       "usb_device");		if (!dev) {			printf("Unable to find parent usb device.");			exit(1);		}#endif		/* From here, we can call get_sysattr_value() for each file		   in the device's /sys entry. The strings passed into these		   functions (idProduct, idVendor, serial, etc.) correspond		   directly to the files in the /sys directory which		   represents the USB device. Note that USB strings are		   Unicode, UCS2 encoded, but the strings returned from		   udev_device_get_sysattr_value() are UTF-8 encoded. */		printf("  VID/PID: %s %s/n",		        udev_device_get_sysattr_value(dev,"idVendor"),		        udev_device_get_sysattr_value(dev, "idProduct"));		printf("  %s/n  %s/n",		        udev_device_get_sysattr_value(dev,"manufacturer"),		        udev_device_get_sysattr_value(dev,"product"));		printf("  serial: %s/n",		         udev_device_get_sysattr_value(dev, "serial"));		udev_device_unref(dev);	}	/* Free the enumerator object *///.........这里部分代码省略.........

static GSList *hw_scan(GSList *options){	int i;	GSList *devices = NULL;	const char *conn = NULL;	const char *serialcomm = NULL;	GSList *l;	struct sr_config *src;	struct udev *udev;	(void)options;	for (l = options; l; l = l->next) {		src = l->data;		switch (src->key) {		case SR_CONF_CONN:			conn = src->value;			break;		case SR_CONF_SERIALCOMM:			serialcomm = src->value;			break;		}	}	if (!conn)		conn = SERIALCONN;	if (serialcomm == NULL)		serialcomm = SERIALCOMM;	udev = udev_new();	if (!udev) {		sr_err("Failed to initialize udev.");	}	struct udev_enumerate *enumerate = udev_enumerate_new(udev);	udev_enumerate_add_match_subsystem(enumerate, "usb-serial");	udev_enumerate_scan_devices(enumerate);	struct udev_list_entry *devs = udev_enumerate_get_list_entry(enumerate);	struct udev_list_entry *dev_list_entry;	for (dev_list_entry = devs;	     dev_list_entry != NULL;	     dev_list_entry = udev_list_entry_get_next(dev_list_entry)) {		const char *syspath = udev_list_entry_get_name(dev_list_entry);		struct udev_device *dev =		    udev_device_new_from_syspath(udev, syspath);		const char *sysname = udev_device_get_sysname(dev);		struct udev_device *parent =		    udev_device_get_parent_with_subsystem_devtype(dev, "usb",								  "usb_device");		if (!parent) {			sr_err("Unable to find parent usb device for %s",			       sysname);			continue;		}		const char *idVendor =		    udev_device_get_sysattr_value(parent, "idVendor");		const char *idProduct =		    udev_device_get_sysattr_value(parent, "idProduct");		if (strcmp(USB_VENDOR, idVendor)		    || strcmp(USB_PRODUCT, idProduct))			continue;		const char *iSerial =		    udev_device_get_sysattr_value(parent, "serial");		const char *iProduct =		    udev_device_get_sysattr_value(parent, "product");		char path[32];		snprintf(path, sizeof(path), "/dev/%s", sysname);		conn = path;		size_t s = strcspn(iProduct, " ");		char product[32];		char manufacturer[32];		if (s > sizeof(product) ||		    strlen(iProduct) - s > sizeof(manufacturer)) {			sr_err("Could not parse iProduct: %s.", iProduct);			continue;		}		strncpy(product, iProduct, s);		product[s] = 0;		strcpy(manufacturer, iProduct + s + 1);		//Create the device context and set its params		struct dev_context *devc;		if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {			sr_err("Device context malloc failed.");			return devices;		}		if (mso_parse_serial(iSerial, iProduct, devc) != SR_OK) {			sr_err("Invalid iSerial: %s.", iSerial);			g_free(devc);			return devices;		}		char hwrev[32];		sprintf(hwrev, "r%d", devc->hwrev);		devc->ctlbase1 = 0;//.........这里部分代码省略.........

//.........这里部分代码省略.........        log_debug("nodes:            %8llu bytes (%8llu)/n",                  (unsigned long long)t.nodes_count * sizeof(struct trie_node_f), (unsigned long long)t.nodes_count);        log_debug("child pointers:   %8llu bytes (%8llu)/n",                  (unsigned long long)t.children_count * sizeof(struct trie_child_entry_f), (unsigned long long)t.children_count);        log_debug("value pointers:   %8llu bytes (%8llu)/n",                  (unsigned long long)t.values_count * sizeof(struct trie_value_entry_f), (unsigned long long)t.values_count);        log_debug("string store:     %8llu bytes/n", (unsigned long long)trie->strings->len);        log_debug("strings start:    %8llu/n", (unsigned long long) t.strings_off);out:        free(filename_tmp);        return err;}static int insert_data(struct trie *trie, struct udev_list *match_list,                       char *line, const char *filename) {        char *value;        struct udev_list_entry *entry;        value = strchr(line, '=');        if (!value) {                log_error("Error, key/value pair expected but got '%s' in '%s':/n", line, filename);                return -EINVAL;        }        value[0] = '/0';        value++;        if (line[0] == '/0' || value[0] == '/0') {                log_error("Error, empty key or value '%s' in '%s':/n", line, filename);                return -EINVAL;        }        udev_list_entry_foreach(entry, udev_list_get_entry(match_list))                trie_insert(trie, trie->root, udev_list_entry_get_name(entry), line, value);        return 0;}static int import_file(struct udev *udev, struct trie *trie, const char *filename) {        enum {                HW_MATCH,                HW_DATA,                HW_NONE,        } state = HW_NONE;        FILE *f;        char line[LINE_MAX];        struct udev_list match_list;        udev_list_init(udev, &match_list, false);        f = fopen(filename, "re");        if (f == NULL)                return -errno;        while (fgets(line, sizeof(line), f)) {                size_t len;                char *pos;                /* comment line */                if (line[0] == '#')                        continue;                /* strip trailing comment */                pos = strchr(line, '#');                if (pos)                        pos[0] = '/0';

int main(int argc, char *argv[]){	struct udev *udev;	struct udev_monitor *mon;	struct udev_device *dev;	const char *path;	const char *dev_node;	const char *action;	udev = udev_new();	if (udev == NULL) {		printf("new uedv error!/n");		return -1;	}	mon = udev_monitor_new_from_netlink(udev, "udev");	if (mon == NULL) {		printf("create mon error!/n");		return -1;	}	if (udev_monitor_filter_add_match_subsystem_devtype(mon,							    "block",							    "disk") < 0) {		printf("udev monitor add match failed!/n");		udev_unref(udev);		return -1;	}	udev_monitor_set_receive_buffer_size(mon, 128*1024);	if (udev_monitor_enable_receiving(mon) < 0) {		printf("monitor enable failed!/n");		udev_monitor_unref(mon);		udev_unref(udev);		return -1;	}	struct udev_enumerate *uenum;	struct udev_list_entry *devs, *dev_list;	uenum = udev_enumerate_new(udev);	if (uenum == NULL) {		printf("uenum create failed.");		return -1;	}	if (udev_enumerate_add_match_subsystem(uenum, "block") < 0) {		printf("uenum add match subsystem failed./n");		return -1;	}	if (udev_enumerate_scan_devices(uenum) < 0) {		printf("uenum scan devices failed./n");		return -1;	}	devs = udev_enumerate_get_list_entry(uenum);	udev_list_entry_foreach(dev_list, devs) {		path = udev_list_entry_get_name(dev_list);		if (path == NULL)			continue;		dev = udev_device_new_from_syspath(udev, path);		if (dev == NULL)			continue;		dev_node = udev_device_get_devnode(dev);		if (dev_node == NULL)			continue;		printf("====enume path:%s, node:%s/n", path, dev_node);	}

jobjectArray getusb_firmware_version(JNIEnv *env, jint usbvid_to_match, jint usbpid_to_match, jstring serial_number) {	int x = 0;	int vid = 0;	int pid = 0;	struct udev *udev_ctx;	struct udev_enumerate *enumerator;	struct udev_list_entry *devices, *dev_list_entry;	const char *sysattr_val;	const char *path;	struct udev_device *udev_device;	char *endptr;	char buffer[128];	const char* serial = NULL;	const char *prop_val;	struct jstrarray_list list = {0};	jstring usb_dev_info;	jclass strClass = NULL;	jobjectArray usbDevicesFwVerFound = NULL;	if(serial_number != NULL) {		serial = (*env)->GetStringUTFChars(env, serial_number, NULL);		if((serial == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) {			throw_serialcom_exception(env, 3, 0, E_GETSTRUTFCHARSTR);			return NULL;		}	}	init_jstrarraylist(&list, 10);	/* libudev is reference counted. Memory is freed when counts reach to zero. */	udev_ctx = udev_new();	enumerator = udev_enumerate_new(udev_ctx);	udev_enumerate_add_match_subsystem(enumerator, "usb");	udev_enumerate_scan_devices(enumerator);	devices = udev_enumerate_get_list_entry(enumerator);	udev_list_entry_foreach(dev_list_entry, devices) {		path = udev_list_entry_get_name(dev_list_entry);		udev_device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerator), path);		if(udev_device == NULL) {			continue;		}		if(strcmp("usb_device", udev_device_get_devtype(udev_device)) == 0) {			/* match vid */			sysattr_val = udev_device_get_sysattr_value(udev_device, "idVendor");			if(sysattr_val != NULL) {				vid = 0x0000FFFF & (int)strtol(sysattr_val, &endptr, 16);				if(vid != usbvid_to_match) {					udev_device_unref(udev_device);					continue;				}			}else {				udev_device_unref(udev_device);				continue;			}			/* match pid */			sysattr_val = udev_device_get_sysattr_value(udev_device, "idProduct");			if(sysattr_val != NULL) {				pid = 0x0000FFFF & (int)strtol(sysattr_val, &endptr, 16);				if(pid != usbpid_to_match) {					udev_device_unref(udev_device);					continue;				}			}else {				udev_device_unref(udev_device);				continue;			}			/* match serial number if requested by application */			if (serial != NULL) {				sysattr_val = udev_device_get_sysattr_value(udev_device, "serial");				if(sysattr_val != NULL) {					if(strcasecmp(sysattr_val, serial) != 0) {						udev_device_unref(udev_device);						continue;					}				}else {					udev_device_unref(udev_device);					continue;				}			}			/* reaching here means that this is the device whose firmware version application need to know. */			prop_val = udev_device_get_property_value(udev_device, "ID_REVISION");			memset(buffer, '/0', sizeof(buffer));			snprintf(buffer, 128, "%d", (0x0000FFFF & (int)strtol(prop_val, &endptr, 16)));			usb_dev_info = (*env)->NewStringUTF(env, buffer);			if((usb_dev_info == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) {				free_jstrarraylist(&list);				udev_device_unref(udev_device);				udev_enumerate_unref(enumerator);				udev_unref(udev_ctx);				throw_serialcom_exception(env, 3, 0, E_NEWSTRUTFSTR);				return NULL;			}			insert_jstrarraylist(&list, usb_dev_info);//.........这里部分代码省略.........

static int show_sysfs_one(                struct udev *udev,                const char *seat,                struct udev_list_entry **item,                const char *sub,                const char *prefix,                unsigned n_columns) {        assert(udev);        assert(seat);        assert(item);        assert(prefix);        while (*item) {                struct udev_list_entry *next, *lookahead;                struct udev_device *d;                const char *sn, *name, *sysfs, *subsystem, *sysname;                char *l, *k;                bool is_master;                sysfs = udev_list_entry_get_name(*item);                if (!path_startswith(sysfs, sub))                        return 0;                d = udev_device_new_from_syspath(udev, sysfs);                if (!d) {                        *item = udev_list_entry_get_next(*item);                        continue;                }                sn = udev_device_get_property_value(d, "ID_SEAT");                if (isempty(sn))                        sn = "seat0";                /* Explicitly also check for tag 'seat' here */                if (!streq(seat, sn) || !udev_device_has_tag(d, "seat")) {                        udev_device_unref(d);                        *item = udev_list_entry_get_next(*item);                        continue;                }                is_master = udev_device_has_tag(d, "seat-master");                name = udev_device_get_sysattr_value(d, "name");                if (!name)                        name = udev_device_get_sysattr_value(d, "id");                subsystem = udev_device_get_subsystem(d);                sysname = udev_device_get_sysname(d);                /* Look if there's more coming after this */                lookahead = next = udev_list_entry_get_next(*item);                while (lookahead) {                        const char *lookahead_sysfs;                        lookahead_sysfs = udev_list_entry_get_name(lookahead);                        if (path_startswith(lookahead_sysfs, sub) &&                            !path_startswith(lookahead_sysfs, sysfs)) {                                struct udev_device *lookahead_d;                                lookahead_d = udev_device_new_from_syspath(udev, lookahead_sysfs);                                if (lookahead_d) {                                        const char *lookahead_sn;                                        bool found;                                        lookahead_sn = udev_device_get_property_value(d, "ID_SEAT");                                        if (isempty(lookahead_sn))                                                lookahead_sn = "seat0";                                        found = streq(seat, lookahead_sn) && udev_device_has_tag(lookahead_d, "seat");                                        udev_device_unref(lookahead_d);                                        if (found)                                                break;                                }                        }                        lookahead = udev_list_entry_get_next(lookahead);                }                k = ellipsize(sysfs, n_columns, 20);                printf("%s%s%s/n", prefix, draw_special_char(lookahead ? DRAW_TREE_BRANCH : DRAW_TREE_RIGHT),                                   k ? k : sysfs);                free(k);                if (asprintf(&l,                             "%s%s:%s%s%s%s",                             is_master ? "[MASTER] " : "",                             subsystem, sysname,                             name ? " /"" : "", name ? name : "", name ? "/"" : "") < 0) {                        udev_device_unref(d);                        return -ENOMEM;                }                k = ellipsize(l, n_columns, 70);                printf("%s%s%s/n", prefix, lookahead ? draw_special_char(DRAW_TREE_VERT) : "  ",                                   k ? k : l);                free(k);                free(l);//.........这里部分代码省略.........

static int node_permissions_apply(struct udev_device *dev, bool apply,                                  mode_t mode, uid_t uid, gid_t gid,                                  struct udev_list *seclabel_list) {        const char *devnode = udev_device_get_devnode(dev);        dev_t devnum = udev_device_get_devnum(dev);        struct stat stats;        struct udev_list_entry *entry;        int err = 0;        if (streq(udev_device_get_subsystem(dev), "block"))                mode |= S_IFBLK;        else                mode |= S_IFCHR;        if (lstat(devnode, &stats) != 0) {                err = -errno;                log_debug_errno(errno, "can not stat() node '%s' (%m)", devnode);                goto out;        }        if (((stats.st_mode & S_IFMT) != (mode & S_IFMT)) || (stats.st_rdev != devnum)) {                err = -EEXIST;                log_debug("found node '%s' with non-matching devnum %s, skip handling",                          udev_device_get_devnode(dev), udev_device_get_id_filename(dev));                goto out;        }        if (apply) {                bool selinux = false;                bool smack = false;                if ((stats.st_mode & 0777) != (mode & 0777) || stats.st_uid != uid || stats.st_gid != gid) {                        log_debug("set permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);                        err = chmod(devnode, mode);                        if (err < 0)                                log_warning_errno(errno, "setting mode of %s to %#o failed: %m", devnode, mode);                        err = chown(devnode, uid, gid);                        if (err < 0)                                log_warning_errno(errno, "setting owner of %s to uid=%u, gid=%u failed: %m", devnode, uid, gid);                } else {                        log_debug("preserve permissions %s, %#o, uid=%u, gid=%u", devnode, mode, uid, gid);                }                /* apply SECLABEL{$module}=$label */                udev_list_entry_foreach(entry, udev_list_get_entry(seclabel_list)) {                        const char *name, *label;                        int r;                        name = udev_list_entry_get_name(entry);                        label = udev_list_entry_get_value(entry);                        if (streq(name, "selinux")) {                                selinux = true;                                r = mac_selinux_apply(devnode, label);                                if (r < 0)                                        log_error_errno(r, "SECLABEL: failed to set SELinux label '%s': %m", label);                                else                                        log_debug("SECLABEL: set SELinux label '%s'", label);                        } else if (streq(name, "smack")) {                                smack = true;                                r = mac_smack_apply(devnode, label);                                if (r < 0)                                        log_error_errno(r, "SECLABEL: failed to set SMACK label '%s': %m", label);                                else                                        log_debug("SECLABEL: set SMACK label '%s'", label);                        } else                                log_error("SECLABEL: unknown subsystem, ignoring '%s'='%s'", name, label);                }                /* set the defaults */                if (!selinux)                        mac_selinux_fix(devnode, true, false);                if (!smack)                        mac_smack_apply(devnode, NULL);        }        /* always update timestamp when we re-use the node, like on media change events */        utimensat(AT_FDCWD, devnode, NULL, 0);out:        return err;}

int main (int argc, char *argv[]){	std::vector<Option> options = {		VerboseOption (),	};	Option help = HelpOption (argv[0], "", &options);	options.push_back (help);	int first_arg;	if (!Option::processOptions (argc, argv, options, first_arg))		return EXIT_FAILURE;	if (argc-first_arg != 0) {		fprintf (stderr, "%s", getUsage (argv[0], "", &options).c_str ());		return EXIT_FAILURE;	}	int ret;	struct udev *ctx = udev_new ();	if (!ctx) {		fprintf (stderr, "Failed to create udev context/n");		return EXIT_FAILURE;	}	struct udev_enumerate *enumerator = udev_enumerate_new (ctx);	if (!enumerator) {		fprintf (stderr, "Failed to create udev enumerator/n");		return EXIT_FAILURE;	}	if (0 != (ret = udev_enumerate_add_match_subsystem (enumerator, "hidraw"))) {		fprintf (stderr, "Failed to add match: %s/n", strerror (ret));		return EXIT_FAILURE;	}	if (0 != (ret = udev_enumerate_scan_devices (enumerator))) {		fprintf (stderr, "Failed to scan devices: %s/n", strerror (ret));		return EXIT_FAILURE;	}	struct udev_list_entry *current;	udev_list_entry_foreach (current, udev_enumerate_get_list_entry (enumerator)) {		struct udev_device *device = udev_device_new_from_syspath (ctx, udev_list_entry_get_name (current));		const char *hidraw_node = udev_device_get_devnode (device);		try {			for (HIDPP::DeviceIndex index: {					HIDPP::DefaultDevice,					HIDPP::CordedDevice,					HIDPP::WirelessDevice1,					HIDPP::WirelessDevice2,					HIDPP::WirelessDevice3,					HIDPP::WirelessDevice4,					HIDPP::WirelessDevice5,					HIDPP::WirelessDevice6 }) {				try {					HIDPP::Device dev (hidraw_node, index);					unsigned int major, minor;					dev.getProtocolVersion (major, minor);					printf ("%s", hidraw_node);					if (index != HIDPP::DefaultDevice)						printf (" (device %d)", index);					printf (": %s (%04hx:%04hx) HID++ %d.%d/n",							dev.name ().c_str (),							dev.vendorID (), dev.productID (),							major, minor);				}				catch (HIDPP10::Error e) {					if (e.errorCode () != HIDPP10::Error::UnknownDevice && e.errorCode () != HIDPP10::Error::InvalidSubID) {						Log::printf (Log::Error,							     "Error while querying %s wireless device %d: %s/n",							     hidraw_node, index, e.what ());					}				}				catch (HIDPP20::Error e) {					Log::printf (Log::Error, "Error while querying %s device %d: %s/n",						     hidraw_node, index, e.what ());				}				catch (HIDRaw::TimeoutError e) {					Log::printf (Log::Warning, "Device %s (index %d) timed out/n",						     hidraw_node, index);				}			}		}		catch (HIDPP::Device::NoHIDPPReportException e) {		}		catch (std::system_error e) {			Log::printf (Log::Warning, "Failed to open %s: %s/n", hidraw_node, e.what ());		}		udev_device_unref (device);	}	udev_enumerate_unref (enumerator);	udev_unref (ctx);	return 0;}

static int builtin_keyboard(struct udev_device *dev, int argc, char *argv[], bool test) {        struct udev_list_entry *entry;        struct {                unsigned int scan;                unsigned int key;        } map[1024];        unsigned int map_count = 0;        unsigned int release[1024];        unsigned int release_count = 0;        udev_list_entry_foreach(entry, udev_device_get_properties_list_entry(dev)) {                const char *key;                unsigned int scancode;                char *endptr;                const char *keycode;                const struct key *k;                key = udev_list_entry_get_name(entry);                if (!startswith(key, "KEYBOARD_KEY_"))                        continue;                /* KEYBOARD_KEY_<hex scan code>=<key identifier string> */                scancode = strtoul(key + 13, &endptr, 16);                if (endptr[0] != '/0') {                        log_error("Error, unable to parse scan code from '%s'", key);                        continue;                }                keycode = udev_list_entry_get_value(entry);                /* a leading '!' needs a force-release entry */                if (keycode[0] == '!') {                        keycode++;                        release[release_count] = scancode;                        if (release_count <  ELEMENTSOF(release)-1)                                release_count++;                        if (keycode[0] == '/0')                                continue;                }                /* translate identifier to key code */                k = keyboard_lookup_key(keycode, strlen(keycode));                if (!k) {                        log_error("Error, unknown key identifier '%s'", keycode);                        continue;                }                map[map_count].scan = scancode;                map[map_count].key = k->id;                if (map_count < ELEMENTSOF(map)-1)                        map_count++;        }        if (map_count > 0 || release_count > 0) {                const char *node;                int fd;                unsigned int i;                node = udev_device_get_devnode(dev);                if (!node) {                        log_error("Error, no device node for '%s'", udev_device_get_syspath(dev));                        return EXIT_FAILURE;                }                fd = open(udev_device_get_devnode(dev), O_RDWR|O_CLOEXEC|O_NONBLOCK|O_NOCTTY);                if (fd < 0) {                        log_error("Error, opening device '%s': %m", node);                        return EXIT_FAILURE;                }                /* install list of map codes */                for (i = 0; i < map_count; i++) {                        log_debug("keyboard: mapping scan code %d (0x%x) to key code %d (0x%x)",                                  map[i].scan, map[i].scan, map[i].key, map[i].key);                        if (ioctl(fd, EVIOCSKEYCODE, &map[i]) < 0)                                log_error("Error calling EVIOCSKEYCODE on device node '%s' (scan code 0x%x, key code %d): %m", node, map[i].scan, map[i].key);                }                /* install list of force-release codes */                if (release_count > 0)                        install_force_release(dev, release, release_count);                close(fd);        }        return EXIT_SUCCESS;}

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;	struct hid_device_info *prev_dev = NULL; /* previous device */	hid_init();	/* 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 *raw_dev; /* The device's hidraw udev node. */		struct udev_device *hid_dev; /* The device's HID udev node. */		struct udev_device *usb_dev; /* The device's USB udev node. */		struct udev_device *intf_dev; /* The device's interface (in the USB sense). */		unsigned short dev_vid;		unsigned short dev_pid;		char *serial_number_utf8 = NULL;		char *product_name_utf8 = NULL;		int bus_type;		int result;		/* 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);		raw_dev = udev_device_new_from_syspath(udev, sysfs_path);		dev_path = udev_device_get_devnode(raw_dev);		hid_dev = udev_device_get_parent_with_subsystem_devtype(			raw_dev,			"hid",			NULL);		if (!hid_dev) {			/* Unable to find parent hid device. */			goto next;		}		result = parse_uevent_info(			udev_device_get_sysattr_value(hid_dev, "uevent"),			&bus_type,			&dev_vid,			&dev_pid,			&serial_number_utf8,			&product_name_utf8);		if (!result) {			/* parse_uevent_info() failed for at least one field. */			goto next;		}		if (bus_type != BUS_USB && bus_type != BUS_BLUETOOTH) {			/* We only know how to handle USB and BT devices. */			goto next;		}		/* Check the VID/PID against the arguments */		if ((vendor_id == 0x0 || vendor_id == dev_vid) &&		    (product_id == 0x0 || product_id == dev_pid)) {			struct hid_device_info *tmp;			/* VID/PID match. Create the record. */			tmp = malloc(sizeof(struct hid_device_info));			if (cur_dev) {				cur_dev->next = tmp;			}			else {				root = tmp;			}			prev_dev = cur_dev;			cur_dev = tmp;			/* Fill out the record */			cur_dev->next = NULL;			cur_dev->path = dev_path? strdup(dev_path): NULL;			/* VID/PID */			cur_dev->vendor_id = dev_vid;			cur_dev->product_id = dev_pid;			/* Serial Number *///.........这里部分代码省略.........

/* * Finds information about USB devices using operating system specific facilities and API. * The sequence of entries in array must match with what java layer expect (6 informations * per USB device). If a particular USB attribute is not set in descriptor or can not be * obtained "---" is placed in its place. * * Return array of USB device's information found, empty array if no USB device is found, * NULL if an error occurs (additionally throws exception). */jobjectArray list_usb_devices(JNIEnv *env, jint vendor_to_match) {	int x = 0;	struct jstrarray_list list = {0};	jstring usb_dev_info;	jclass strClass = NULL;	jobjectArray usbDevicesFound = NULL;	struct udev *udev_ctx;	struct udev_enumerate *enumerator;	struct udev_list_entry *devices, *dev_list_entry;	const char *sysattr_val;	const char *path;	struct udev_device *udev_device;	char *endptr;	init_jstrarraylist(&list, 100);	/* libudev is reference counted. Memory is freed when counts reach to zero. */	udev_ctx = udev_new();	enumerator = udev_enumerate_new(udev_ctx);	udev_enumerate_add_match_subsystem(enumerator, "usb");	udev_enumerate_scan_devices(enumerator);	devices = udev_enumerate_get_list_entry(enumerator);	udev_list_entry_foreach(dev_list_entry, devices) {		path = udev_list_entry_get_name(dev_list_entry);		udev_device = udev_device_new_from_syspath(udev_enumerate_get_udev(enumerator), path);		if(udev_device == NULL) {			continue;		}		if(strcmp("usb_device", udev_device_get_devtype(udev_device)) == 0) {			/* USB-IF vendor ID */			sysattr_val = udev_device_get_sysattr_value(udev_device, "idVendor");			if(sysattr_val != NULL) {				if(vendor_to_match != 0) {					/* we need to apply filter for identify specific vendor */					if(vendor_to_match != (0x0000FFFF & (int)strtol(sysattr_val, &endptr, 16))) {						udev_device_unref(udev_device);						continue;					}				}				usb_dev_info = (*env)->NewStringUTF(env, sysattr_val);			}else {				usb_dev_info = (*env)->NewStringUTF(env, "---");			}			if((usb_dev_info == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) {				return linux_listusb_clean_throw_exp(env, 1, NULL, &list, udev_device, enumerator, udev_ctx);			}			insert_jstrarraylist(&list, usb_dev_info);			/* USB product ID */			sysattr_val = udev_device_get_sysattr_value(udev_device, "idProduct");			if(sysattr_val != NULL) {				usb_dev_info = (*env)->NewStringUTF(env, sysattr_val);			}else {				usb_dev_info = (*env)->NewStringUTF(env, "---");			}			if((usb_dev_info == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) {				return linux_listusb_clean_throw_exp(env, 1, NULL, &list, udev_device, enumerator, udev_ctx);			}			insert_jstrarraylist(&list, usb_dev_info);			/* SERIAL NUMBER */			sysattr_val = udev_device_get_sysattr_value(udev_device, "serial");			if(sysattr_val != NULL) {				usb_dev_info = (*env)->NewStringUTF(env, sysattr_val);			}else {				usb_dev_info = (*env)->NewStringUTF(env, "---");			}			if((usb_dev_info == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) {				return linux_listusb_clean_throw_exp(env, 1, NULL, &list, udev_device, enumerator, udev_ctx);			}			insert_jstrarraylist(&list, usb_dev_info);			/* PRODUCT */			sysattr_val = udev_device_get_sysattr_value(udev_device, "product");			if(sysattr_val != NULL) {				usb_dev_info = (*env)->NewStringUTF(env, sysattr_val);			}else {				usb_dev_info = (*env)->NewStringUTF(env, "---");			}			if((usb_dev_info == NULL) || ((*env)->ExceptionOccurred(env) != NULL)) {				return linux_listusb_clean_throw_exp(env, 1, NULL, &list, udev_device, enumerator, udev_ctx);			}			insert_jstrarraylist(&list, usb_dev_info);			/* MANUFACTURER */			sysattr_val = udev_device_get_sysattr_value(udev_device, "manufacturer");			if(sysattr_val != NULL) {				usb_dev_info = (*env)->NewStringUTF(env, sysattr_val);//.........这里部分代码省略.........

XN_THREAD_PROC xnUSBUDEVEventsThread(XN_THREAD_PARAM pThreadParam){	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);	}	/* This section sets up a monitor which will report events when	   devices attached to the system change.  Events include "add",	   "remove", "change", "online", and "offline".	   	   This section sets up and starts the monitoring. Events are	   polled for (and delivered) later on.	   	   It is important that the monitor be set up before the call to	   udev_enumerate_scan_devices() so that events (and devices) are	   not missed.  For example, if enumeration happened first, there	   would be no event generated for a device which was attached after	   enumeration but before monitoring began.	   	   Note that a filter is added so that we only get events for	   "usb/usb_device" devices. */		/* Set up a monitor to monitor "usb_device" devices */	mon = udev_monitor_new_from_netlink(udev, "udev");	udev_monitor_filter_add_match_subsystem_devtype(mon, "usb", "usb_device");	udev_monitor_enable_receiving(mon);	/* Get the file descriptor (fd) for the monitor.	   This fd will get passed to select() */	fd = udev_monitor_get_fd(mon);		//////////////////////////////////////////////////////////////////////////	/* Enumerate the currently connected devices and store them, 	   so we can notify of their disconnection */	struct udev_enumerate *enumerate;	struct udev_list_entry *devices, *dev_list_entry;	enumerate = udev_enumerate_new(udev);	/* Create a list of the devices.	   Note that it's not possible to match by "devtype="usb_device"",	   as in monitor filter, but this filter combination seems to do the job... */	udev_enumerate_add_match_subsystem(enumerate, "usb");	udev_enumerate_add_match_sysattr(enumerate, "idVendor", NULL);	udev_enumerate_add_match_sysattr(enumerate, "idProduct", NULL);	udev_enumerate_add_match_sysattr(enumerate, "busnum", NULL);	udev_enumerate_add_match_sysattr(enumerate, "devnum", NULL);	udev_enumerate_scan_devices(enumerate);	devices = udev_enumerate_get_list_entry(enumerate);	/* udev_list_entry_foreach is a macro which expands to	   a loop. The loop will be executed for each member in	   devices, setting dev_list_entry to a list entry	   which contains the device's path in /sys. */	udev_list_entry_foreach(dev_list_entry, devices) {		const char *path;				/* Get the filename of the /sys entry for the device		   and create a udev_device object (dev) representing it */		path = udev_list_entry_get_name(dev_list_entry);		dev = udev_device_new_from_syspath(udev, path);		/* Notify as if it was just connected */		// note - it's better that connectivity events register AFTER this point,		//        so they don't get notified of already connected devices.		xnUSBDeviceConnected(dev);			udev_device_unref(dev);	}	/* Free the enumerator object */	udev_enumerate_unref(enumerate);	//////////////////////////////////////////////////////////////////////////	/* Begin polling for udev events. Events occur when devices	   attached to the system are added, removed, or change state. 	   udev_monitor_receive_device() will return a device	   object representing the device which changed and what type of	   change occured.	   The select() system call is used to ensure that the call to	   udev_monitor_receive_device() will not block.	   	   The monitor was set up earler in this file, and monitoring is	   already underway.	   	   This section will run continuously, calling usleep() at the end	   of each pass. This is to demonstrate how to use a udev_monitor	   in a non-blocking way. */	while (g_bShouldRunUDEVThread)	{//.........这里部分代码省略.........