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

static void set_trackpoint_sensitivity(struct udev_device *dev, const char *value){        struct udev_device *pdev;        char val_s[DECIMAL_STR_MAX(int)];        int r, val_i;        assert(dev);        assert(value);        /* The sensitivity sysfs attr belongs to the serio parent device */        pdev = udev_device_get_parent_with_subsystem_devtype(dev, "serio", NULL);        if (!pdev) {                log_warning("Failed to get serio parent for '%s'", udev_device_get_devnode(dev));                return;        }        r = safe_atoi(value, &val_i);        if (r < 0) {                log_error("Unable to parse POINTINGSTICK_SENSITIVITY '%s' for '%s'", value, udev_device_get_devnode(dev));                return;        }        xsprintf(val_s, "%d", val_i);        r = udev_device_set_sysattr_value(pdev, "sensitivity", val_s);        if (r < 0)                log_error_errno(r, "Failed to write 'sensitivity' attribute for '%s': %m", udev_device_get_devnode(pdev));}

static struct udev_device *handle_scsi_fibre_channel(struct udev_device *parent, char **path){	struct udev *udev  = udev_device_get_udev(parent);	struct udev_device *targetdev;	struct udev_device *fcdev = NULL;	const char *port;	unsigned int lun;	targetdev = udev_device_get_parent_with_subsystem_devtype(parent, "scsi", "scsi_target");	if (targetdev == NULL)		return NULL;	fcdev = udev_device_new_from_subsystem_sysname(udev, "fc_transport", udev_device_get_sysname(targetdev));	if (fcdev == NULL)		return NULL;	port = udev_device_get_sysattr_value(fcdev, "port_name");	if (port == NULL) {		parent = NULL;		goto out;	}	lun = strtoul(udev_device_get_sysnum(parent), NULL, 10);	path_prepend(path, "fc-%s:0x%04x%04x00000000", port, lun & 0xffff, (lun >> 16) & 0xffff);out:	udev_device_unref(fcdev);	return parent;}

static int install_force_release(struct udev_device *dev, const unsigned int *release, unsigned int release_count) {        struct udev_device *atkbd;        const char *cur;        char codes[4096];        char *s;        size_t l;        unsigned int i;        int ret;        atkbd = udev_device_get_parent_with_subsystem_devtype(dev, "serio", NULL);        if (!atkbd)                return -ENODEV;        cur = udev_device_get_sysattr_value(atkbd, "force_release");        if (!cur)                return -ENODEV;        s = codes;        l = sizeof(codes);        /* copy current content */        l = strpcpy(&s, l, cur);        /* append new codes */        for (i = 0; i < release_count; i++)                l = strpcpyf(&s, l, ",%d", release[i]);        log_debug("keyboard: updating force-release list with '%s'", codes);        ret = udev_device_set_sysattr_value(atkbd, "force_release", codes);        if (ret < 0)                log_error("Error writing force-release attribute: %s", strerror(-ret));        return ret;}

static int builtin_input_id(struct udev_device *dev, int argc, char *argv[], bool test){        struct udev_device *pdev;        unsigned long bitmask_ev[NBITS(EV_MAX)];        unsigned long bitmask_abs[NBITS(ABS_MAX)];        unsigned long bitmask_key[NBITS(KEY_MAX)];        unsigned long bitmask_rel[NBITS(REL_MAX)];        /* walk up the parental chain until we find the real input device; the         * argument is very likely a subdevice of this, like eventN */        pdev = dev;        while (pdev != NULL && udev_device_get_sysattr_value(pdev, "capabilities/ev") == NULL)                pdev = udev_device_get_parent_with_subsystem_devtype(pdev, "input", NULL);        /* not an "input" class device */        if (pdev == NULL)                return EXIT_SUCCESS;        /* Use this as a flag that input devices were detected, so that this         * program doesn't need to be called more than once per device */        udev_builtin_add_property(dev, test, "ID_INPUT", "1");        get_cap_mask(dev, pdev, "capabilities/ev", bitmask_ev, sizeof(bitmask_ev), test);        get_cap_mask(dev, pdev, "capabilities/abs", bitmask_abs, sizeof(bitmask_abs), test);        get_cap_mask(dev, pdev, "capabilities/rel", bitmask_rel, sizeof(bitmask_rel), test);        get_cap_mask(dev, pdev, "capabilities/key", bitmask_key, sizeof(bitmask_key), test);        test_pointers(dev, bitmask_ev, bitmask_abs, bitmask_key, bitmask_rel, test);        test_key(dev, bitmask_ev, bitmask_key, test);        return EXIT_SUCCESS;}

static int names_pci(struct udev_device *dev, struct netnames *names) {        struct udev_device *parent;        assert(dev);        assert(names);        parent = udev_device_get_parent(dev);        /* there can only ever be one virtio bus per parent device, so we can           safely ignore any virtio buses. see           <http://lists.linuxfoundation.org/pipermail/virtualization/2015-August/030331.html> */        while (parent && streq_ptr("virtio", udev_device_get_subsystem(parent)))                parent = udev_device_get_parent(parent);        if (!parent)                return -ENOENT;        /* check if our direct parent is a PCI device with no other bus in-between */        if (streq_ptr("pci", udev_device_get_subsystem(parent))) {                names->type = NET_PCI;                names->pcidev = parent;        } else {                names->pcidev = udev_device_get_parent_with_subsystem_devtype(dev, "pci", NULL);                if (!names->pcidev)                        return -ENOENT;        }        dev_pci_onboard(dev, names);        dev_pci_slot(dev, names);        return 0;}

QStringList QDeviceDiscovery::scanConnectedDevices(){    QStringList devices;    if (!m_udev)        return devices;    udev_enumerate *ue = udev_enumerate_new(m_udev);    udev_enumerate_add_match_subsystem(ue, "input");    udev_enumerate_add_match_subsystem(ue, "drm");    if (m_types & Device_Mouse)        udev_enumerate_add_match_property(ue, "ID_INPUT_MOUSE", "1");    if (m_types & Device_Touchpad)        udev_enumerate_add_match_property(ue, "ID_INPUT_TOUCHPAD", "1");    if (m_types & Device_Touchscreen)        udev_enumerate_add_match_property(ue, "ID_INPUT_TOUCHSCREEN", "1");    if (m_types & Device_Keyboard) {        udev_enumerate_add_match_property(ue, "ID_INPUT_KEYBOARD", "1");        udev_enumerate_add_match_property(ue, "ID_INPUT_KEY", "1");    }    if (m_types & Device_Tablet)        udev_enumerate_add_match_property(ue, "ID_INPUT_TABLET", "1");    if (udev_enumerate_scan_devices(ue) != 0) {#ifdef QT_QPA_DEVICE_DISCOVERY_DEBUG        qWarning() << "UDeviceHelper scan connected devices for enumeration failed";#endif        return devices;    }    udev_list_entry *entry;    udev_list_entry_foreach (entry, udev_enumerate_get_list_entry(ue)) {        const char *syspath = udev_list_entry_get_name(entry);        udev_device *udevice = udev_device_new_from_syspath(m_udev, syspath);        QString candidate = QString::fromUtf8(udev_device_get_devnode(udevice));        if ((m_types & Device_InputMask) && candidate.startsWith(QLatin1String(QT_EVDEV_DEVICE)))            devices << candidate;        if ((m_types & Device_VideoMask) && candidate.startsWith(QLatin1String(QT_DRM_DEVICE))) {            if (m_types & Device_DRM_PrimaryGPU) {                udev_device *pci = udev_device_get_parent_with_subsystem_devtype(udevice, "pci", 0);                if (pci) {                    if (qstrcmp(udev_device_get_sysattr_value(pci, "boot_vga"), "1") == 0)                        devices << candidate;                }            } else                devices << candidate;        }        udev_device_unref(udevice);    }    udev_enumerate_unref(ue);#ifdef QT_QPA_DEVICE_DISCOVERY_DEBUG    qWarning() << "UDeviceHelper found matching devices" << devices;#endif    return devices;}

QUdevDeviceList QUdevPrivate::getUDevDevicesForSubsystem(const QString &strSubSystem, const QString &strDeviceType, const QString &strParentSubSystem, const QString &strParentDeviceType){    struct udev_enumerate *enumerate = udev_enumerate_new(m_pUdev);    struct udev_list_entry *devices = 0;    struct udev_list_entry *dev_list_entry = 0;    struct udev_device *dev = 0;    QList<QUdevDevice> lDevices;    if(strSubSystem.isEmpty()) return lDevices;    //get subsystem enumerator    udev_enumerate_add_match_subsystem(enumerate, strSubSystem.toLatin1().constData());    //perform sysfs scanning    udev_enumerate_scan_devices(enumerate);    devices = udev_enumerate_get_list_entry(enumerate);    //iterate over all devices in the enumeration list    udev_list_entry_foreach(dev_list_entry, devices)    {        QUdevDevice udDev;        //create udev device for the sysfs path returned        udDev.m_strSysfsPath = QString::fromLatin1(udev_list_entry_get_name(dev_list_entry));                dev = udev_device_new_from_syspath(m_pUdev, udDev.m_strSysfsPath.toLatin1().constData());        //filter the correct device types, ignored if empty device type is specified        if(strDeviceType.isEmpty() || (QString::fromLatin1(udev_device_get_devtype(dev)) == strDeviceType))        {            //get the path inside /dev            udDev.m_strDevPath = QString::fromLatin1(udev_device_get_devnode(dev));            udDev.m_strSubsystem = strSubSystem;            udDev.m_strDeviceType = strDeviceType;            //if the caller wants a specific parent subsystem/devtype query the sysfs tree here            if(!strParentSubSystem.isEmpty() && !strParentDeviceType.isEmpty())            {                /*                 * retrieve the parent device with the subsystem/devtype pair of m_strParentSubSystem/m_strParentDeviceType.                 *                 * udev_device_get_parent_with_subsystem_devtype() will walk up the complete tree if needed                 */                dev = udev_device_get_parent_with_subsystem_devtype(dev, strParentSubSystem.toLatin1().constData(), strParentDeviceType.toLatin1().constData());            }            if(dev)            {                //fill the device information                udDev.m_strVendorID = QString::fromLatin1(udev_device_get_sysattr_value(dev,"idVendor"));                udDev.m_strProductID = QString::fromLatin1(udev_device_get_sysattr_value(dev, "idProduct"));                udDev.m_strManufacturer = QString::fromLatin1(udev_device_get_sysattr_value(dev,"manufacturer"));                udDev.m_strProduct = QString::fromLatin1(udev_device_get_sysattr_value(dev,"product"));                udDev.m_strSerial = QString::fromLatin1(udev_device_get_sysattr_value(dev, "serial"));                lDevices.append(udDev);            }            udev_device_unref(dev);        }    }

  /*      This implementation uses udev to retrieve capture devices.     We support both udev and default v4l2 ways to retrieve      devices. Udev is not supported on all systems.   */  std::vector<V4L2_Device> v4l2_get_devices() {        std::vector<V4L2_Device> result;    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 result;    }     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) {      /* Get the device by syspath. */      const char* syspath = udev_list_entry_get_name(dev_list_entry);      dev = udev_device_new_from_syspath(udev, syspath);      if(!dev) {        printf("Error: cannot get the device using the syspath: %s/n", syspath);        continue;      }      V4L2_Device v4l2_device;      v4l2_device.path = udev_device_get_devnode(dev);      if(v4l2_device.path.size() == 0) {        printf("Error: Cannot find devpath./n");        continue;      }      dev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device");      if(!dev) {        printf("Error:Cannot find related usb device./n");        continue;      }      v4l2_device.id_vendor = udev_device_get_sysattr_value(dev, "idVendor");      v4l2_device.id_product = udev_device_get_sysattr_value(dev, "idProduct");      result.push_back(v4l2_device);    }    udev_enumerate_unref(enumerate);    udev_unref(udev);        return result;  }

static int names_usb(struct udev_device *dev, struct netnames *names) {        struct udev_device *usbdev;        char name[256];        char *ports;        char *config;        char *interf;        size_t l;        char *s;        assert(dev);        assert(names);        usbdev = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_interface");        if (!usbdev)                return -ENOENT;        /* get USB port number chain, configuration, interface */        strscpy(name, sizeof(name), udev_device_get_sysname(usbdev));        s = strchr(name, '-');        if (!s)                return -EINVAL;        ports = s+1;        s = strchr(ports, ':');        if (!s)                return -EINVAL;        s[0] = '/0';        config = s+1;        s = strchr(config, '.');        if (!s)                return -EINVAL;        s[0] = '/0';        interf = s+1;        /* prefix every port number in the chain with "u" */        s = ports;        while ((s = strchr(s, '.')))                s[0] = 'u';        s = names->usb_ports;        l = strpcpyl(&s, sizeof(names->usb_ports), "u", ports, NULL);        /* append USB config number, suppress the common config == 1 */        if (!streq(config, "1"))                l = strpcpyl(&s, sizeof(names->usb_ports), "c", config, NULL);        /* append USB interface number, suppress the interface == 0 */        if (!streq(interf, "0"))                l = strpcpyl(&s, sizeof(names->usb_ports), "i", interf, NULL);        if (l == 0)                return -ENAMETOOLONG;        names->type = NET_USB;        return 0;}

UdevDevice UdevDevice::getParent(const char* subsystem,const char* deviceType)	{	/* Get the parent device: */	udev_device* parent=udev_device_get_parent_with_subsystem_devtype(device,subsystem,deviceType);		/* The parent device is not supposed to be unref'ed, so let's explicitly ref it here so that a later unref won't hurt: */	if(parent!=0)		udev_device_ref(parent);		return UdevDevice(parent);	}

int find_and_open_p6s() {    int result = -1;    char buf[300];    memset(buf, 0, sizeof(buf));    get_usb_device_syspath(ID_VENDOR_YEALINK,ID_PRODUCT_VOIPUSBPHONE, buf);    int len = strlen(buf);    if (len==0) {        return result;    }    printf("Found Skypemate P6S USB at %s /n", buf);    struct udev* udev;    struct udev_enumerate* enumerate;    struct udev_list_entry* dev_list_entry;    struct udev_device* dev;    udev = udev_new();    if (udev<0) {        perror("error creating udev object");        return result;    }    // enumerating all hidraw devices    enumerate = udev_enumerate_new(udev);    udev_enumerate_add_match_subsystem(enumerate, "hidraw");    udev_enumerate_scan_devices(enumerate);    dev_list_entry = udev_enumerate_get_list_entry(enumerate);    while ((dev_list_entry!=0) && (result==-1)) {        const char* syspath = udev_list_entry_get_name(dev_list_entry);        dev = udev_device_new_from_syspath(udev, syspath);        // get hidraw USB parent        struct udev_device* parent = udev_device_get_parent_with_subsystem_devtype(dev, "usb","usb_device");        if (parent != 0) {            const char* parent_syspath = udev_device_get_syspath(parent);            if ( strcmp(buf, parent_syspath) == 0) {                // found it                const char* devnode = udev_device_get_devnode(dev);                printf("Found corresponding hidraw device: %s /n", devnode);                result = open(devnode, O_RDONLY);            }        }        udev_device_unref(dev);        dev_list_entry = udev_list_entry_get_next(dev_list_entry);    }    udev_enumerate_unref(enumerate);    udev_unref(udev);    return result;}

int main (int argc, char** argv){	struct udev *udev;	struct udev_device *dev;	char devpath[PATH_MAX];	unsigned long bitmask_ev[NBITS(EV_MAX)];	unsigned long bitmask_abs[NBITS(ABS_MAX)];	unsigned long bitmask_key[NBITS(KEY_MAX)];        unsigned long bitmask_rel[NBITS(REL_MAX)];	if (argc != 2) {		fprintf(stderr, "Usage: %s <device path (without /sys)>/n", argv[0]);		exit(1);	}	/* get the device */	udev = udev_new();	if (udev == NULL)		return 1;	snprintf(devpath, sizeof(devpath), "%s/%s", udev_get_sys_path(udev), argv[1]);	dev = udev_device_new_from_syspath(udev, devpath);	if (dev == NULL) {		fprintf(stderr, "unable to access '%s'/n", devpath);		return 1;	}	/* walk up the parental chain until we find the real input device; the	 * argument is very likely a subdevice of this, like eventN */	while (dev != NULL && udev_device_get_sysattr_value(dev, "capabilities/ev") == NULL)		dev = udev_device_get_parent_with_subsystem_devtype(dev, "input", NULL);	/* not an "input" class device */	if (dev == NULL)		return 0;	/* Use this as a flag that input devices were detected, so that this	 * program doesn't need to be called more than once per device */	puts("ID_INPUT=1");	get_cap_mask (dev, "capabilities/ev", bitmask_ev, sizeof (bitmask_ev));	get_cap_mask (dev, "capabilities/abs", bitmask_abs, sizeof (bitmask_abs));	get_cap_mask (dev, "capabilities/rel", bitmask_rel, sizeof (bitmask_rel));	get_cap_mask (dev, "capabilities/key", bitmask_key, sizeof (bitmask_key));	test_pointers(bitmask_ev, bitmask_abs, bitmask_key, bitmask_rel);	test_key(bitmask_ev, bitmask_key);	return 0;}

Device Device::ancestorOfType(const QString &subsys, const QString &devtype) const{    if (!d)        return Device();    struct udev_device *p = udev_device_get_parent_with_subsystem_devtype(d->udev,                                subsys.toLatin1().constData(), devtype.toLatin1().constData());    if (!p)        return Device();    return Device(new DevicePrivate(p));}

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

static int builtin_input_id(struct udev_device *dev, int argc, char *argv[], bool test) {        struct udev_device *pdev;        unsigned long bitmask_ev[NBITS(EV_MAX)];        unsigned long bitmask_abs[NBITS(ABS_MAX)];        unsigned long bitmask_key[NBITS(KEY_MAX)];        unsigned long bitmask_rel[NBITS(REL_MAX)];        unsigned long bitmask_props[NBITS(INPUT_PROP_MAX)];        const char *sysname, *devnode;        bool is_pointer;        bool is_key;        assert(dev);        /* walk up the parental chain until we find the real input device; the         * argument is very likely a subdevice of this, like eventN */        pdev = dev;        while (pdev != NULL && udev_device_get_sysattr_value(pdev, "capabilities/ev") == NULL)                pdev = udev_device_get_parent_with_subsystem_devtype(pdev, "input", NULL);        if (pdev) {                /* Use this as a flag that input devices were detected, so that this                 * program doesn't need to be called more than once per device */                udev_builtin_add_property(dev, test, "ID_INPUT", "1");                get_cap_mask(dev, pdev, "capabilities/ev", bitmask_ev, sizeof(bitmask_ev), test);                get_cap_mask(dev, pdev, "capabilities/abs", bitmask_abs, sizeof(bitmask_abs), test);                get_cap_mask(dev, pdev, "capabilities/rel", bitmask_rel, sizeof(bitmask_rel), test);                get_cap_mask(dev, pdev, "capabilities/key", bitmask_key, sizeof(bitmask_key), test);                get_cap_mask(dev, pdev, "properties", bitmask_props, sizeof(bitmask_props), test);                is_pointer = test_pointers(dev, bitmask_ev, bitmask_abs,                                           bitmask_key, bitmask_rel,                                           bitmask_props, test);                is_key = test_key(dev, bitmask_ev, bitmask_key, test);                /* Some evdev nodes have only a scrollwheel */                if (!is_pointer && !is_key && test_bit(EV_REL, bitmask_ev) &&                    (test_bit(REL_WHEEL, bitmask_rel) || test_bit(REL_HWHEEL, bitmask_rel)))                        udev_builtin_add_property(dev, test, "ID_INPUT_KEY", "1");                if (test_bit(EV_SW, bitmask_ev))                        udev_builtin_add_property(dev, test, "ID_INPUT_SWITCH", "1");        }        devnode = udev_device_get_devnode(dev);        sysname = udev_device_get_sysname(dev);        if (devnode && sysname && startswith(sysname, "event"))                extract_info(dev, devnode, test);        return EXIT_SUCCESS;}

static int get_device_string(hid_device *dev, const char *key, wchar_t *string, size_t maxlen){	struct udev *udev;	struct udev_device *udev_dev, *parent;	struct stat s;	int ret = -1;		setlocale(LC_ALL,"");	/* Create the udev object */	udev = udev_new();	if (!udev) {		printf("Can't create udev/n");		return -1;	}	/* Get the dev_t (major/minor numbers) from the file handle. */	fstat(dev->device_handle, &s);	/* Open a udev device from the dev_t. 'c' means character device. */	udev_dev = udev_device_new_from_devnum(udev, 'c', s.st_rdev);	if (udev_dev) {		const char *str;		/* Find the parent USB Device */		parent = udev_device_get_parent_with_subsystem_devtype(		       udev_dev,		       "usb",		       "usb_device");		if (parent) {			str = udev_device_get_sysattr_value(parent, key);			if (str) {				/* Convert the string from UTF-8 to wchar_t */				ret = mbstowcs(string, str, maxlen);				goto end;			}		}	}end:	udev_device_unref(udev_dev);	// parent doesn't need to be (and can't be) unref'd.	// I'm not sure why, but it'll throw double-free() errors.	udev_unref(udev);	return ret;}

static int names_bcma(struct udev_device *dev, struct netnames *names) {        struct udev_device *bcmadev;        unsigned int core;        bcmadev = udev_device_get_parent_with_subsystem_devtype(dev, "bcma", NULL);        if (!bcmadev)                return -ENOENT;        /* bus num:core num */        if (sscanf(udev_device_get_sysname(bcmadev), "bcma%*d:%d", &core) != 1)                return -EINVAL;        /* suppress the common core == 0 */        if (core > 0)                snprintf(names->bcma_core, sizeof(names->bcma_core), "b%d", core);        names->type = NET_BCMA;        return 0;}

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

static int names_pci(struct udev_device *dev, struct netnames *names) {        struct udev_device *parent;        parent = udev_device_get_parent(dev);        if (!parent)                return -ENOENT;        /* check if our direct parent is a PCI device with no other bus in-between */        if (streq_ptr("pci", udev_device_get_subsystem(parent))) {                names->type = NET_PCI;                names->pcidev = parent;        } else {                names->pcidev = udev_device_get_parent_with_subsystem_devtype(dev, "pci", NULL);                if (!names->pcidev)                        return -ENOENT;        }        dev_pci_onboard(dev, names);        dev_pci_slot(dev, names);        return 0;}

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

static int names_pci(struct udev_device *dev, struct netnames *names) {        struct udev_device *parent;        static int do_virtio = -1;        if (do_virtio < 0) {                _cleanup_free_ char *value = NULL;                int n = 0;                do_virtio = 0;                if (get_proc_cmdline_key("net.ifnames", NULL) > 0)                        do_virtio = 1;                else if (get_proc_cmdline_key("net.ifnames=", &value) > 0) {                        safe_atoi(value, &n);                        if (n > 0)                                do_virtio = 1;                }        }        parent = udev_device_get_parent(dev);        /* there can only ever be one virtio bus per parent device, so we can           safely ignore any virtio buses. see           <http://lists.linuxfoundation.org/pipermail/virtualization/2015-August/030331.html> */        if (do_virtio > 0)                while (parent && streq_ptr("virtio", udev_device_get_subsystem(parent)))                        parent = udev_device_get_parent(parent);        if (!parent)                return -ENOENT;        /* check if our direct parent is a PCI device with no other bus in-between */        if (streq_ptr("pci", udev_device_get_subsystem(parent))) {                names->type = NET_PCI;                names->pcidev = parent;        } else {                names->pcidev = udev_device_get_parent_with_subsystem_devtype(dev, "pci", NULL);                if (!names->pcidev)                        return -ENOENT;        }        dev_pci_onboard(dev, names);        dev_pci_slot(dev, names);        return 0;}

static void add_device(const char *syspath, const char *devname,			const char *driver, const char *vendor,			const char *model, struct udev_device *device){	struct udev_device *intf;	const char *devpath, *devnode, *interface, *number, *label, *sysattr;	struct modem_info *modem;	struct device_info *info;	devpath = udev_device_get_syspath(device);	if (devpath == NULL)		return;	devnode = udev_device_get_devnode(device);	if (devnode == NULL) {		devnode = udev_device_get_property_value(device, "INTERFACE");		if (devnode == NULL)			return;	}	intf = udev_device_get_parent_with_subsystem_devtype(device,						"usb", "usb_interface");	if (intf == NULL)		return;	modem = g_hash_table_lookup(modem_list, syspath);	if (modem == NULL) {		modem = g_try_new0(struct modem_info, 1);		if (modem == NULL)			return;		modem->syspath = g_strdup(syspath);		modem->devname = g_strdup(devname);		modem->driver = g_strdup(driver);		modem->vendor = g_strdup(vendor);		modem->model = g_strdup(model);		modem->sysattr = get_sysattr(driver);		g_hash_table_replace(modem_list, modem->syspath, modem);	}

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

static int get_supported_device(struct udev_device *udevice, uint16_t *bus){	struct udev_device *hid_parent;	uint16_t vid, pid;	const char *hid_id;	guint i;	hid_parent = udev_device_get_parent_with_subsystem_devtype(udevice,								"hid", NULL);	if (!hid_parent)		return -1;	hid_id = udev_device_get_property_value(hid_parent, "HID_ID");	if (sscanf(hid_id, "%hx:%hx:%hx", bus, &vid, &pid) != 3)		return -1;	for (i = 0; i < G_N_ELEMENTS(devices); i++) {		if (devices[i].vid == vid && devices[i].pid == pid)			return i;	}	return -1;}

static struct udev_device *handle_ccw(struct udev_device *parent, struct udev_device *dev, char **path){	struct udev_device *scsi_dev;	scsi_dev = udev_device_get_parent_with_subsystem_devtype(dev, "scsi", "scsi_device");	if (scsi_dev != NULL) {		const char *wwpn;		const char *lun;		const char *hba_id;		hba_id = udev_device_get_sysattr_value(scsi_dev, "hba_id");		wwpn = udev_device_get_sysattr_value(scsi_dev, "wwpn");		lun = udev_device_get_sysattr_value(scsi_dev, "fcp_lun");		if (hba_id != NULL && lun != NULL && wwpn != NULL) {			path_prepend(path, "ccw-%s-zfcp-%s:%s", hba_id, wwpn, lun);			goto out;		}	}	path_prepend(path, "ccw-%s", udev_device_get_sysname(parent));out:	parent = skip_subsystem(parent, "ccw");	return parent;}

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