Example #1
0
QDeviceDiscovery::~QDeviceDiscovery()
{
    if (m_udevMonitor)
        udev_monitor_unref(m_udevMonitor);

    if (m_udev)
        udev_unref(m_udev);
}
Example #2
0
UdevSubsystem::~UdevSubsystem()
{
  if (m_monitor)
  {
    udev_monitor_unref(m_monitor);
  }
  udev_unref(m_udev);
}
Example #3
0
void joystick_linux::run_joystick_thread() {

	udev *_udev = udev_new();
	ERR_FAIL_COND(!_udev);
	enumerate_joysticks(_udev);
	monitor_joysticks(_udev);
	udev_unref(_udev);
}
Example #4
0
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);
}
Example #7
0
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);
}
Example #8
0
UdevDeviceNotifier::~UdevDeviceNotifier()
{
    if (m_monitor) {
        udev_monitor_unref(m_monitor);
    }
    if (m_udev) {
        udev_unref(m_udev);
    }
}
Example #9
0
 LinuxDeviceManager::~LinuxDeviceManager()
 {
   setDefaultBlockedState(/*state=*/false); // FIXME: Set to previous state
   stop();
   udev_monitor_unref(_umon);
   udev_unref(_udev);
   close(_event_fd);
   return;
 }
Example #10
0
static virInterfacePtr
udevInterfaceLookupByMACString(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;
}
Example #11
0
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;
}
Example #12
0
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
}
Example #14
0
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);
}
Example #16
0
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
}
Example #17
0
/**
 * 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;
}
Example #19
0
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;
  }
}
Example #20
0
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);
}
Example #22
0
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;
}
Example #23
0
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;
}
Example #24
0
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);
}
Example #25
0
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;
}
Example #26
0
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;
}
Example #27
0
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;
}
Example #28
0
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;
}
Example #29
0
static int
udev_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;
}
Example #30
0
static void
udev_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);
}