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

void manager_free(Manager *m) {        Network *network;        NetDev *netdev;        Link *link;        if (!m)                return;        udev_monitor_unref(m->udev_monitor);        udev_unref(m->udev);        sd_bus_unref(m->bus);        sd_event_source_unref(m->udev_event_source);        sd_event_source_unref(m->sigterm_event_source);        sd_event_source_unref(m->sigint_event_source);        sd_event_unref(m->event);        while ((network = m->networks))                network_free(network);        while ((link = hashmap_first(m->links)))                link_free(link);        hashmap_free(m->links);        while ((netdev = hashmap_first(m->netdevs)))                netdev_free(netdev);        hashmap_free(m->netdevs);        sd_rtnl_unref(m->rtnl);        free(m);}

int linux_udev_stop_event_monitor(void){	char dummy = 1;	int r;	assert(udev_ctx != NULL);	assert(udev_monitor != NULL);	assert(udev_monitor_fd != -1);	/* Write some dummy data to the control pipe and	 * wait for the thread to exit */	r = usbi_write(udev_control_pipe[1], &dummy, sizeof(dummy));	if (r <= 0) {		usbi_warn(NULL, "udev control pipe signal failed");	}	pthread_join(linux_event_thread, NULL);	/* Release the udev monitor */	udev_monitor_unref(udev_monitor);	udev_monitor = NULL;	udev_monitor_fd = -1;	/* Clean up the udev context */	udev_unref(udev_ctx);	udev_ctx = NULL;	/* close and reset control pipe */	close(udev_control_pipe[0]);	close(udev_control_pipe[1]);	udev_control_pipe[0] = -1;	udev_control_pipe[1] = -1;	return LIBUSB_SUCCESS;}

static int vlc_sd_probe_Open (vlc_object_t *obj){    vlc_probe_t *probe = (vlc_probe_t *)obj;    struct udev *udev = udev_new ();    if (udev == NULL)        return VLC_PROBE_CONTINUE;    struct udev_monitor *mon = udev_monitor_new_from_netlink (udev, "udev");    if (mon != NULL)    {        vlc_sd_probe_Add (probe, "v4l{longname=/"Video capture/"}",                          N_("Video capture"), SD_CAT_DEVICES);#ifdef HAVE_ALSA        if (!module_exists ("pulselist"))            vlc_sd_probe_Add (probe, "alsa{longname=/"Audio capture/"}",                              N_("Audio capture"), SD_CAT_DEVICES);#endif        vlc_sd_probe_Add (probe, "disc{longname=/"Discs/"}", N_("Discs"),                          SD_CAT_DEVICES);        udev_monitor_unref (mon);    }    udev_unref (udev);    return VLC_PROBE_CONTINUE;}

void manager_free(Manager *m) {        Network *network;        Bridge *bridge;        Link *link;        udev_monitor_unref(m->udev_monitor);        udev_unref(m->udev);        sd_bus_unref(m->bus);        sd_event_source_unref(m->udev_event_source);        sd_event_unref(m->event);        while ((network = m->networks))                network_free(network);        while ((link = hashmap_first(m->links)))                link_free(link);        hashmap_free(m->links);        while ((bridge = hashmap_first(m->bridges)))                bridge_free(bridge);        hashmap_free(m->bridges);        sd_rtnl_unref(m->rtnl);        free(m);}

int linux_udev_start_event_monitor(void){	int r;	assert(udev_ctx == NULL);	udev_ctx = udev_new();	if (!udev_ctx) {		usbi_err(NULL, "could not create udev context");		return LIBUSB_ERROR_OTHER;	}	udev_monitor = udev_monitor_new_from_netlink(udev_ctx, "udev");	if (!udev_monitor) {		usbi_err(NULL, "could not initialize udev monitor");		goto err_free_ctx;	}	r = udev_monitor_filter_add_match_subsystem_devtype(udev_monitor, "usb", 0);	if (r) {		usbi_err(NULL, "could not initialize udev monitor filter for /"usb/" subsystem");		goto err_free_monitor;	}	if (udev_monitor_enable_receiving(udev_monitor)) {		usbi_err(NULL, "failed to enable the udev monitor");		goto err_free_monitor;	}	udev_monitor_fd = udev_monitor_get_fd(udev_monitor);	/* Some older versions of udev are not non-blocking by default,	 * so make sure this is set */	r = fcntl(udev_monitor_fd, F_GETFL);	if (r == -1) {		usbi_err(NULL, "getting udev monitor fd flags (%d)", errno);		goto err_free_monitor;	}	r = fcntl(udev_monitor_fd, F_SETFL, r | O_NONBLOCK);	if (r) {		usbi_err(NULL, "setting udev monitor fd flags (%d)", errno);		goto err_free_monitor;	}	r = pthread_create(&linux_event_thread, NULL, linux_udev_event_thread_main, NULL);	if (r) {		usbi_err(NULL, "creating hotplug event thread (%d)", r);		goto err_free_monitor;	}	return LIBUSB_SUCCESS;err_free_monitor:	udev_monitor_unref(udev_monitor);	udev_monitor = NULL;	udev_monitor_fd = -1;err_free_ctx:	udev_unref(udev_ctx);	udev_ctx = NULL;	return LIBUSB_ERROR_OTHER;}

void pa__done(pa_module *m) {    struct userdata *u;    pa_assert(m);    if (!(u = m->userdata))        return;    if (u->udev_io)        m->core->mainloop->io_free(u->udev_io);    if (u->monitor)        udev_monitor_unref(u->monitor);    if (u->udev)        udev_unref(u->udev);    if (u->inotify_io)        m->core->mainloop->io_free(u->inotify_io);    if (u->inotify_fd >= 0)        pa_close(u->inotify_fd);    if (u->devices)        pa_hashmap_free(u->devices);    pa_xfree(u);}

UdevListener::~UdevListener(){    delete socketNotifier;    udev_monitor_unref(mon);    udev_unref(udev);}

void pa__done(pa_module *m) {    struct userdata *u;    pa_assert(m);    if (!(u = m->userdata))        return;    if (u->udev_io)        m->core->mainloop->io_free(u->udev_io);    if (u->monitor)        udev_monitor_unref(u->monitor);    if (u->udev)        udev_unref(u->udev);    if (u->inotify_io)        m->core->mainloop->io_free(u->inotify_io);    if (u->inotify_fd >= 0)        pa_close(u->inotify_fd);    if (u->devices) {        struct device *d;        while ((d = pa_hashmap_steal_first(u->devices)))            device_free(d);        pa_hashmap_free(u->devices, NULL, NULL);    }    pa_xfree(u);}

static void manager_free(struct manager *m){	unsigned int i;	struct link *l;	if (!m)		return;	while ((l = MANAGER_FIRST_LINK(m)))		link_free(l);	manager_dbus_disconnect(m);	shl_htable_clear_uint(&m->links, NULL, NULL);	sd_event_source_unref(m->udev_mon_source);	udev_monitor_unref(m->udev_mon);	udev_unref(m->udev);	for (i = 0; m->sigs[i]; ++i)		sd_event_source_unref(m->sigs[i]);	sd_bus_unref(m->bus);	sd_event_unref(m->event);	free(m->friendly_name);	free(m);}

static void udev_input_free(void *data){   unsigned i;   udev_input_t *udev = (udev_input_t*)data;   if (!data || !udev)      return;   if (udev->joypad)      udev->joypad->destroy();   epoll_free(&udev->epfd);   for (i = 0; i < udev->num_devices; i++)   {      close(udev->devices[i]->fd);      free(udev->devices[i]);   }   free(udev->devices);   if (udev->monitor)      udev_monitor_unref(udev->monitor);   if (udev->udev)      udev_unref(udev->udev);   udev_input_kb_free();   free(udev);}

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

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

void deInitaccessory(Accessory* accessory){	udev_monitor_unref(accessory->udev_monitor);	udev_unref(accessory->udev_context);	libusb_exit(accessory->usb_context);	bt_close(accessory->bt_service);	free(accessory);}

UdevSubsystem::~UdevSubsystem(){  if (m_monitor)  {    udev_monitor_unref(m_monitor);  }  udev_unref(m_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; }

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

udev_monitor_ptr Root::mk_monitor(char const *name) const{    udev_monitor_ptr res        (udev_monitor_new_from_netlink(p.get(), name)         , [](udev_monitor *p) {            if (p) udev_monitor_unref(p);        });    return res;}

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

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

    void DeviceManager::finiHotplug()    {        if (fdHotplug >= 0)        {            close(fdHotplug);            udev_monitor_unref(hotplugMonitor);            fdHotplug = -255;        }    }

void joystick_linux::monitor_joysticks(udev *p_udev) {	udev_device *dev = NULL;	udev_monitor *mon = udev_monitor_new_from_netlink(p_udev, "udev");	udev_monitor_filter_add_match_subsystem_devtype(mon, "input", NULL);	udev_monitor_enable_receiving(mon);	int fd = udev_monitor_get_fd(mon);	while (!exit_udev) {		fd_set fds;		struct timeval tv;		int ret;		FD_ZERO(&fds);		FD_SET(fd, &fds);		tv.tv_sec = 0;		tv.tv_usec = 0;		ret = select(fd+1, &fds, NULL, NULL, &tv);		/* Check if our file descriptor has received data. */		if (ret > 0 && FD_ISSET(fd, &fds)) {			/* Make the call to receive the device.			   select() ensured that this will not block. */			dev = udev_monitor_receive_device(mon);			if (dev && udev_device_get_devnode(dev) != 0) {				joy_mutex->lock();				String action = udev_device_get_action(dev);				const char* devnode = udev_device_get_devnode(dev);				if (devnode) {					String devnode_str = devnode;					if (devnode_str.find(ignore_str) == -1) {						if (action == "add")							open_joystick(devnode);						else if (String(action) == "remove")							close_joystick(get_joy_from_path(devnode));					}				}				udev_device_unref(dev);				joy_mutex->unlock();			}		}		usleep(50000);	}	//printf("exit udev/n");	udev_monitor_unref(mon);}

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

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

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

static voidudev_stop(void){	if (monitor) {		udev_monitor_unref(monitor);		monitor = NULL;	}	if (udev) {		udev_unref(udev);		udev = NULL;	}}

int usbmain(){    // Load the uinput module (if it's not loaded already)    if(system("modprobe uinput") != 0)        ckb_warn("Failed to load uinput module/n");    // Create the udev object    if(!(udev = udev_new())){        ckb_fatal("Failed to initialize udev/n");        return -1;    }    // Enumerate all currently connected devices    udev_enum();    // Done scanning. Enter a loop to poll for device updates    struct udev_monitor* monitor = udev_monitor_new_from_netlink(udev, "udev");    udev_monitor_filter_add_match_subsystem_devtype(monitor, "usb", 0);    udev_monitor_enable_receiving(monitor);    // Get an fd for the monitor    int fd = udev_monitor_get_fd(monitor);    fd_set fds;    while(udev){        FD_ZERO(&fds);        FD_SET(fd, &fds);        // Block until an event is read        if(select(fd + 1, &fds, 0, 0, 0) > 0 && FD_ISSET(fd, &fds)){            struct udev_device* dev = udev_monitor_receive_device(monitor);            if(!dev)                continue;            const char* action = udev_device_get_action(dev);            if(!action){                udev_device_unref(dev);                continue;            }            // Add/remove device            if(!strcmp(action, "add")){                int res = usb_add_device(dev);                if(res == 0)                    continue;                // If the device matched but the handle wasn't opened correctly, re-enumerate (this sometimes solves the problem)                if(res == -1)                    udev_enum();            } else if(!strcmp(action, "remove"))                usb_rm_device(dev);            udev_device_unref(dev);        }    }    udev_monitor_unref(monitor);    return 0;}

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