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

QDeviceDiscovery::~QDeviceDiscovery(){    if (m_udevMonitor)        udev_monitor_unref(m_udevMonitor);    if (m_udev)        udev_unref(m_udev);}

UdevSubsystem::~UdevSubsystem(){  if (m_monitor)  {    udev_monitor_unref(m_monitor);  }  udev_unref(m_udev);}

void joystick_linux::run_joystick_thread() {	udev *_udev = udev_new();	ERR_FAIL_COND(!_udev);	enumerate_joysticks(_udev);	monitor_joysticks(_udev);	udev_unref(_udev);}

ClientPrivate::~ClientPrivate(){    udev_unref(udev);    delete monitorNotifier;    if (monitor)        udev_monitor_unref(monitor);}

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

void testdisplay_cleanup_hotplug(void){	if (udevchannel)		g_io_channel_shutdown(udevchannel, TRUE, NULL);	if (uevent_monitor)		udev_monitor_unref(uevent_monitor);	if (udev)		udev_unref(udev);}

udev_handler::~udev_handler() {  if (monitor_thread) {    stop_thread = true;    monitor_thread->join();    delete monitor_thread;  }  if (monitor) udev_monitor_unref(monitor);  if (udev) udev_unref(udev);}

UdevDeviceNotifier::~UdevDeviceNotifier(){    if (m_monitor) {        udev_monitor_unref(m_monitor);    }    if (m_udev) {        udev_unref(m_udev);    }}

 LinuxDeviceManager::~LinuxDeviceManager() {   setDefaultBlockedState(/*state=*/false); // FIXME: Set to previous state   stop();   udev_monitor_unref(_umon);   udev_unref(_udev);   close(_event_fd);   return; }

static virInterfacePtrudevInterfaceLookupByMACString(virConnectPtr conn, const char *macstr){    struct udev_iface_driver *driverState = conn->interfacePrivateData;    struct udev *udev = udev_ref(driverState->udev);    struct udev_enumerate *enumerate = NULL;    struct udev_list_entry *dev_entry;    struct udev_device *dev;    const char *name;    virInterfacePtr ret = NULL;    enumerate = udevGetDevices(udev, VIR_UDEV_IFACE_ALL);    if (!enumerate) {        virReportError(VIR_ERR_INTERNAL_ERROR,                       _("failed to lookup interface with MAC address '%s'"),                       macstr);        goto err;    }    /* Match on MAC */    udev_enumerate_add_match_sysattr(enumerate, "address", macstr);    /* Do the scan to load up the enumeration */    udev_enumerate_scan_devices(enumerate);    /* Get a list we can walk */    dev_entry = udev_enumerate_get_list_entry(enumerate);    /* Check that we got something back */    if (!dev_entry) {        virReportError(VIR_ERR_NO_INTERFACE,                       _("couldn't find interface with MAC address '%s'"),                       macstr);        goto err;    }    /* Check that we didn't get multiple items back */    if (udev_list_entry_get_next(dev_entry)) {        virReportError(VIR_ERR_MULTIPLE_INTERFACES,                       _("the MAC address '%s' matches multiple interfaces"),                       macstr);        goto err;    }    dev = udev_device_new_from_syspath(udev, udev_list_entry_get_name(dev_entry));    name = udev_device_get_sysname(dev);    ret = virGetInterface(conn, name, macstr);    udev_device_unref(dev);err:    if (enumerate)        udev_enumerate_unref(enumerate);    udev_unref(udev);    return ret;}

int usbip_vhci_driver_open(void){	udev_context = udev_new();	if (!udev_context) {		err("udev_new failed");		return -1;	}	vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver));	/* will be freed in usbip_driver_close() */	vhci_driver->hc_device =		udev_device_new_from_subsystem_sysname(udev_context,						       USBIP_VHCI_BUS_TYPE,						       USBIP_VHCI_DEVICE_NAME);	if (!vhci_driver->hc_device) {		err("udev_device_new_from_subsystem_sysname failed");		goto err;	}	vhci_driver->nports = get_nports();	dbg("available ports: %d", vhci_driver->nports);	if (vhci_driver->nports <= 0) {		err("no available ports");		goto err;	} else if (vhci_driver->nports > MAXNPORT) {		err("port number exceeds %d", MAXNPORT);		goto err;	}	vhci_driver->ncontrollers = get_ncontrollers();	dbg("available controllers: %d", vhci_driver->ncontrollers);	if (vhci_driver->ncontrollers <=0) {		err("no available usb controllers");		goto err;	}	if (refresh_imported_device_list())		goto err;	return 0;err:	udev_device_unref(vhci_driver->hc_device);	if (vhci_driver)		free(vhci_driver);	vhci_driver = NULL;	udev_unref(udev_context);	return -1;}

QUdevPrivate &QUdevPrivate::operator=(const QUdevPrivate& Other){    if(this != &Other)    {        if(m_pUdev) udev_unref(m_pUdev);        m_pUdev = Other.m_pUdev;        m_lMonitorEntries = Other.m_lMonitorEntries;    }    return *this;}

QNetworkInfoPrivate::~QNetworkInfoPrivate(){#if !defined(QT_NO_UDEV)    if (udevMonitor)        udev_monitor_unref(udevMonitor);    if (udevHandle)        udev_unref(udevHandle);#endif // QT_NO_UDEV}

GamepadController::~GamepadController(){    udev_unref(m_udev);    udev_monitor_unref(m_gamepadsMonitor);    for (unsigned i = 0; i <= m_gamepadDevices.size(); i++)        delete m_gamepadDevices[i];    m_gamepadDevices.clear();}

LibinputServer::~LibinputServer(){#ifdef KEY_INPUT_HANDLING_VIRTUAL    if (m_virtualkeyboard != nullptr) {       Destruct(m_virtualkeyboard);    }#endif    libinput_unref(m_libinput);    udev_unref(m_udev);}

void JoypadLinux::run_joypad_thread() {#ifdef UDEV_ENABLED	udev *_udev = udev_new();	ERR_FAIL_COND(!_udev);	enumerate_joypads(_udev);	monitor_joypads(_udev);	udev_unref(_udev);#else	monitor_joypads();#endif}

/** * Search all Joystick devices */gboolean search_devices(GList **list_controllers) {  int i;  Controller_info *ctrl_info;  struct udev *udev;  struct udev_device *dev;  for(i = 0; i < 32; ++i) {    gchar *str = NULL;    str = g_strdup_printf("/dev/input/js%d", i);    int fd = open(str, O_RDONLY);    if (fd < 0) {      //printf("Could not found joystick: %s/n", str->str);      break;    } else {      ctrl_info = g_malloc(sizeof(Controller_info));      uint8_t num_axis   = 0;      uint8_t num_button = 0;      ioctl(fd, JSIOCGAXES,    &num_axis);      ioctl(fd, JSIOCGBUTTONS, &num_button);      ctrl_info->filename    = g_strdup(str);      ctrl_info->num_axis    = num_axis;      ctrl_info->num_buttons = num_button;      // Get Name       char name_c_str[1024];      if (ioctl(fd, JSIOCGNAME(sizeof(name_c_str)), name_c_str) < 0) {          printf("%s : %s", str, strerror(errno));          break;      } else {         ctrl_info->name = g_convert_with_fallback(name_c_str, sizeof(name_c_str), "UTF-8", "ISO-8859-1", NULL, NULL, NULL, NULL);      }      /* Create the udev object */      udev = udev_new();      if (!udev) {        printf("Can't create udev/n");        exit(0);      }      dev = udev_device_new_from_subsystem_sysname(udev, "input", g_strdup_printf("js%d", i));      if (dev == NULL)            break;      ctrl_info->serial = uint32_atoi(g_strdup_printf("%s%s", udev_list_entry_get_value(udev_list_entry_get_by_name(udev_device_get_properties_list_entry(dev), "ID_VENDOR_ID")), udev_list_entry_get_value(udev_list_entry_get_by_name(udev_device_get_properties_list_entry(dev), "ID_MODEL_ID"))));      udev_device_unref(dev);      udev_unref(udev);      printf("%s : %d, %d, 0x%08x/n", ctrl_info->name, ctrl_info->num_axis, ctrl_info->num_buttons, ctrl_info->serial);    }    *list_controllers = g_list_append(*list_controllers, ctrl_info);    close(fd);  }  return TRUE;}

int udev_init_library_context(void){    if (_udev)        udev_unref(_udev);    if (!(_udev = udev_new())) {        log_error("Failed to create udev library context.");        return 0;    }    return 1;}

void CALSADeviceMonitor::Stop(){  if (m_udev)  {    g_fdEventMonitor.RemoveFD(m_fdMonitorId);    udev_monitor_unref(m_udevMonitor);    m_udevMonitor = NULL;    udev_unref(m_udev);    m_udev = NULL;  }}

void UdevEventPublisher::tearDown() {  WriteLock lock(mutex_);  if (monitor_ != nullptr) {    udev_monitor_unref(monitor_);    monitor_ = nullptr;  }  if (handle_ != nullptr) {    udev_unref(handle_);    handle_ = nullptr;  }}

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

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

char *dri2_get_driver_for_fd(int fd){   struct udev *udev;   struct udev_device *device, *parent;   const char *pci_id;   char *driver = NULL;   int vendor_id, chip_id, i, j;   udev = udev_new();   device = dri2_udev_device_new_from_fd(udev, fd);   if (device == NULL)      return NULL;   parent = udev_device_get_parent(device);   if (parent == NULL) {      _eglLog(_EGL_WARNING, "DRI2: could not get parent device");      goto out;   }   pci_id = udev_device_get_property_value(parent, "PCI_ID");   if (pci_id == NULL ||       sscanf(pci_id, "%x:%x", &vendor_id, &chip_id) != 2) {      _eglLog(_EGL_WARNING, "EGL-DRI2: malformed or no PCI ID");      goto out;   }   for (i = 0; driver_map[i].driver; i++) {      if (vendor_id != driver_map[i].vendor_id)         continue;      if (driver_map[i].num_chips_ids == -1) {         driver = strdup(driver_map[i].driver);         _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s",                 fd, vendor_id, chip_id, driver);         goto out;      }      for (j = 0; j < driver_map[i].num_chips_ids; j++)         if (driver_map[i].chip_ids[j] == chip_id) {            driver = strdup(driver_map[i].driver);            _eglLog(_EGL_DEBUG, "pci id for %d: %04x:%04x, driver %s",                    fd, vendor_id, chip_id, driver);            goto out;         }   }out:   udev_device_unref(device);   udev_unref(udev);   return driver;}

void usbip_vhci_driver_close(){	if (!vhci_driver)		return;	udev_device_unref(vhci_driver->hc_device);	free(vhci_driver);	vhci_driver = NULL;	udev_unref(udev_context);}

static void sixaxis_exit(void){	DBG("");	g_source_remove(watch_id);	watch_id = 0;	udev_monitor_unref(monitor);	monitor = NULL;	udev_unref(ctx);	ctx = NULL;}

int main(int argc, char **argv){        struct udev *udev;        int retval = 0;        char maj_min_dev[MAX_PATH_LEN];        int newargc;        char **newargv;        udev = udev_new();        if (udev == NULL)                goto exit;        log_open();        udev_set_log_fn(udev, log_fn);        /*         * Get config file options.         */        newargv = NULL;        retval = get_file_options(udev, NULL, NULL, &newargc, &newargv);        if (retval < 0) {                retval = 1;                goto exit;        }        if (newargv && (retval == 0)) {                if (set_options(udev, newargc, newargv, short_options, maj_min_dev) < 0) {                        retval = 2;                        goto exit;                }                free(newargv);        }        /*         * Get command line options (overriding any config file settings).         */        if (set_options(udev, argc, argv, short_options, maj_min_dev) < 0)                exit(1);        if (!dev_specified) {                log_error("no device specified/n");                retval = 1;                goto exit;        }        retval = scsi_id(udev, maj_min_dev);exit:        udev_unref(udev);        log_close();        return retval;}

UdevContext &UdevContext::operator=(const UdevContext &other){  if (this != &other) {    ScopeLock protect(udev_context_mutex);    struct udev *new_ud = (nullptr == other.ud) ? udev_ref(other.ud) : nullptr;    assert(nullptr == other.ud || nullptr != new_ud);    if (ud != nullptr)      udev_unref(ud);    ud = new_ud;  }  return *this;}

int show_sysfs(const char *seat, const char *prefix, unsigned n_columns) {        struct udev *udev;        struct udev_list_entry *first = NULL;        struct udev_enumerate *e;        int r;        if (n_columns <= 0)                n_columns = columns();        if (!prefix)                prefix = "";        if (isempty(seat))                seat = "seat0";        udev = udev_new();        if (!udev)                return -ENOMEM;        e = udev_enumerate_new(udev);        if (!e) {                r = -ENOMEM;                goto finish;        }        if (!streq(seat, "seat0"))                r = udev_enumerate_add_match_tag(e, seat);        else                r = udev_enumerate_add_match_tag(e, "seat");        if (r < 0)                goto finish;        r = udev_enumerate_scan_devices(e);        if (r < 0)                goto finish;        first = udev_enumerate_get_list_entry(e);        if (first)                show_sysfs_one(udev, seat, &first, "/", prefix, n_columns);finish:        if (e)                udev_enumerate_unref(e);        if (udev)                udev_unref(udev);        return r;}

static intudev_open(struct sol_flow_node *node, void *data, const struct sol_flow_node_options *options){    struct udev_data *mdata = data;    struct udev_device *device;    bool value;    const struct sol_flow_node_type_udev_boolean_options *opts =        (const struct sol_flow_node_type_udev_boolean_options *)options;    SOL_FLOW_NODE_OPTIONS_SUB_API_CHECK(options,        SOL_FLOW_NODE_TYPE_UDEV_BOOLEAN_OPTIONS_API_VERSION, -EINVAL);    mdata->udev = udev_new();    SOL_NULL_CHECK(mdata->udev, -EINVAL);    mdata->monitor = udev_monitor_new_from_netlink(mdata->udev, "udev");    if (!mdata->monitor) {        SOL_WRN("Fail on create the udev monitor");        goto monitor_error;    }    if (udev_monitor_enable_receiving(mdata->monitor) < 0) {        SOL_WRN("error: unable to subscribe to udev events");        goto receive_error;    }    mdata->addr = strdup(opts->address);    mdata->node = node;    mdata->watch = sol_fd_add(udev_monitor_get_fd(mdata->monitor),        SOL_FD_FLAGS_IN | SOL_FD_FLAGS_ERR | SOL_FD_FLAGS_HUP,        _on_event, mdata);    device = udev_device_new_from_syspath(mdata->udev, mdata->addr);    if (device) {        value = true;        udev_device_unref(device);    } else {        value = false;    }    return sol_flow_send_boolean_packet(node,        SOL_FLOW_NODE_TYPE_UDEV_BOOLEAN__OUT__OUT, value);receive_error:    mdata->monitor = udev_monitor_unref(mdata->monitor);monitor_error:    mdata->udev = udev_unref(mdata->udev);    return -EINVAL;}

static voidudev_close(struct sol_flow_node *node, void *data){    struct udev_data *mdata = data;    if (mdata->watch) {        sol_fd_del(mdata->watch);        mdata->watch = NULL;    }    mdata->monitor = udev_monitor_unref(mdata->monitor);    mdata->udev = udev_unref(mdata->udev);    free(mdata->addr);}