ftdi_device_t* ftdi_context_match_name(const ftdi_context_t* context,
const char* name) {
struct stat stat_buffer;
struct udev* udev = 0;
struct udev_device* dev = 0;
int bus = 0;
int address = 0;
int i;
if (!stat(name, &stat_buffer) && S_ISCHR(stat_buffer.st_mode)) {
udev = udev_new();
dev = udev_device_new_from_devnum(udev, 'c', stat_buffer.st_rdev);
if (dev) {
string_scanf(udev_device_get_sysattr_value(dev, "busnum"),
"%d", &bus);
string_scanf(udev_device_get_sysattr_value(dev, "devnum"),
"%d", &address);
}
udev_unref(udev);
}
for (i = 0; i < context->num_devices; ++i) {
if ((context->devices[i].bus == bus) &&
(context->devices[i].address == address))
return &context->devices[i];
}
return 0;
}
int get_device_count()
{
struct udev *udev = udev_new();
if (!udev)
{
return -1;
}
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "usb");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
const char *path;
int count = 0;
udev_list_entry_foreach(dev_list_entry, devices)
{
path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, path);
if(!dev)
return -1;
const char * vid = udev_device_get_sysattr_value(dev,"idVendor");
const char * pid = udev_device_get_sysattr_value(dev,"idProduct");
if((vid && pid) && (!strcmp(vid, "04d8") && (!strcmp(pid, "e11c"))))
count++;
udev_device_unref(dev);
}
static int names_mac(struct udev_device *dev, struct netnames *names) {
const char *s;
unsigned int i;
unsigned int a1, a2, a3, a4, a5, a6;
/* check for NET_ADDR_PERM, skip random MAC addresses */
s = udev_device_get_sysattr_value(dev, "addr_assign_type");
if (!s)
return EXIT_FAILURE;
i = strtoul(s, NULL, 0);
if (i != 0)
return 0;
s = udev_device_get_sysattr_value(dev, "address");
if (!s)
return -ENOENT;
if (sscanf(s, "%x:%x:%x:%x:%x:%x", &a1, &a2, &a3, &a4, &a5, &a6) != 6)
return -EINVAL;
/* skip empty MAC addresses */
if (a1 + a2 + a3 + a4 + a5 + a6 == 0)
return -EINVAL;
names->mac[0] = a1;
names->mac[1] = a2;
names->mac[2] = a3;
names->mac[3] = a4;
names->mac[4] = a5;
names->mac[5] = a6;
names->mac_valid = true;
return 0;
}
static int find_device(struct udev_device *udev_dev)
{
char path[PATH_MAX];
const char *busnum, *devnum;
int fd;
busnum = udev_device_get_sysattr_value(udev_dev, "busnum");
if (!busnum)
return -1;
devnum = udev_device_get_sysattr_value(udev_dev, "devnum");
if (!devnum)
return -1;
snprintf(path, sizeof(path), "/dev/bus/usb/%s/%s", busnum, devnum);
fd = open(path, O_RDWR, O_CLOEXEC);
if (fd < 0) {
fprintf(stderr, "Can't open device: %s (%d)\n",
strerror(errno), errno);
return -1;
}
return fd;
}
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);
}
}
LinuxDevice::LinuxDevice(struct udev_device* dev)
{
log->debug("Creating a new LinuxDevice instance");
const char *name = udev_device_get_sysattr_value(dev, "product");
if (name) {
log->debug("DeviceName={}", name);
setDeviceName(name);
}
const char *id_vendor = udev_device_get_sysattr_value(dev, "idVendor");
if (id_vendor) {
log->debug("VendorID={}", id_vendor);
setVendorID(id_vendor);
}
const char *id_product = udev_device_get_sysattr_value(dev, "idProduct");
if (id_product) {
log->debug("ProductID={}", id_product);
setProductID(id_product);
}
const char *serial = udev_device_get_sysattr_value(dev, "serial");
if (serial) {
log->debug("Serial={}", serial);
setSerialNumber(serial);
}
const char *syspath = udev_device_get_syspath(dev);
if (syspath) {
log->debug("Syspath={}", syspath);
_syspath = syspath;
} else {
throw std::runtime_error("device wihtout syspath");
}
const char *sysname = udev_device_get_sysname(dev);
if (sysname) {
log->debug("Sysname={}", sysname);
setDevicePort(sysname);
} else {
throw std::runtime_error("device wihtout sysname");
}
log->debug("DeviceHash={}", getDeviceHash());
setTarget(Rule::Target::Unknown);
std::ifstream descriptor_stream(_syspath + "/descriptors", std::ifstream::binary);
if (!descriptor_stream.good()) {
throw std::runtime_error("cannot load USB descriptors");
}
else {
readDescriptors(descriptor_stream);
}
return;
}
/*
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 struct udev_device *handle_scsi_iscsi(struct udev_device *parent, char **path)
{
struct udev *udev = udev_device_get_udev(parent);
struct udev_device *transportdev;
struct udev_device *sessiondev = NULL;
const char *target;
char *connname;
struct udev_device *conndev = NULL;
const char *addr;
const char *port;
/* find iscsi session */
transportdev = parent;
while (1) {
transportdev = udev_device_get_parent(transportdev);
if (transportdev == NULL)
return NULL;
if (strncmp(udev_device_get_sysname(transportdev), "session", 7) == 0)
break;
}
if (transportdev == NULL)
return NULL;
/* find iscsi session device */
sessiondev = udev_device_new_from_subsystem_sysname(udev, "iscsi_session", udev_device_get_sysname(transportdev));
if (sessiondev == NULL)
return NULL;
target = udev_device_get_sysattr_value(sessiondev, "targetname");
if (target == NULL) {
parent = NULL;
goto out;
}
if (asprintf(&connname, "connection%s:0", udev_device_get_sysnum(transportdev)) < 0) {
parent = NULL;
goto out;
}
conndev = udev_device_new_from_subsystem_sysname(udev, "iscsi_connection", connname);
free(connname);
if (conndev == NULL) {
parent = NULL;
goto out;
}
addr = udev_device_get_sysattr_value(conndev, "persistent_address");
port = udev_device_get_sysattr_value(conndev, "persistent_port");
if (addr == NULL || port == NULL) {
parent = NULL;
goto out;
}
path_prepend(path, "ip-%s:%s-iscsi-%s-lun-%s", addr, port, target, udev_device_get_sysnum(parent));
out:
udev_device_unref(sessiondev);
udev_device_unref(conndev);
return parent;
}
int get_usbinfo(int bus, int dev, usbinfo_t *ui)
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *udev_dev;
char bus_str[16], dev_str[16];
int found = 0;
memset(ui, 0, sizeof(usbinfo_t));
/* construct xenstore dev id */
if (dev > 0xFFF) {
xd_log(LOG_ERR, "bad device id %d", dev);
return -EINVAL;
}
ui->usb_virtid = bus << 12 | (dev & 0xFFF);
ui->usb_bus = bus;
ui->usb_device = dev;
/* udev scan */
udev = udev_new();
if (!udev) {
xd_log(LOG_ERR, "Can't create udev");
return -ENOMEM;
}
enumerate = udev_enumerate_new(udev);
if (!enumerate) {
xd_log(LOG_ERR, "Can't create enumeration");
return -ENOMEM;
}
snprintf(bus_str, sizeof(bus_str), "%d", bus);
snprintf(dev_str, sizeof(dev_str), "%d", dev);
udev_enumerate_add_match_subsystem(enumerate, "usb");
udev_enumerate_add_match_sysattr(enumerate, "busnum", bus_str);
udev_enumerate_add_match_sysattr(enumerate, "devnum", dev_str);
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path;
path = udev_list_entry_get_name(dev_list_entry);
udev_dev = udev_device_new_from_syspath(udev, path);
sscanf(udev_device_get_sysattr_value(udev_dev, "idVendor"), "%x", &ui->usb_vendor);
sscanf(udev_device_get_sysattr_value(udev_dev, "idProduct"), "%x", &ui->usb_product);
udev_device_unref(udev_dev);
udev_enumerate_unref(enumerate);
udev_unref(udev);
return 0;
}
udev_enumerate_unref(enumerate);
udev_unref(udev);
return -ENOENT;
}
/*@null@*/ static struct _driverTracker *get_driver(struct udev_device *dev,
const char *devpath, struct _driverTracker **classdriver)
{
int i;
unsigned int idVendor, idProduct;
static struct _driverTracker *driver;
const char *str;
str = udev_device_get_sysattr_value(dev, "idVendor");
if (!str)
{
Log1(PCSC_LOG_ERROR, "udev_device_get_sysattr_value() failed");
return NULL;
}
sscanf(str, "%X", &idVendor);
str = udev_device_get_sysattr_value(dev, "idProduct");
if (!str)
{
Log1(PCSC_LOG_ERROR, "udev_device_get_sysattr_value() failed");
return NULL;
}
sscanf(str, "%X", &idProduct);
Log4(PCSC_LOG_DEBUG,
"Looking for a driver for VID: 0x%04X, PID: 0x%04X, path: %s",
idVendor, idProduct, devpath);
*classdriver = NULL;
driver = NULL;
/* check if the device is supported by one driver */
for (i=0; i<driverSize; i++)
{
if (driverTracker[i].libraryPath != NULL &&
idVendor == driverTracker[i].manuID &&
idProduct == driverTracker[i].productID)
{
if ((driverTracker[i].CFBundleName != NULL)
&& (0 == strcmp(driverTracker[i].CFBundleName, "CCIDCLASSDRIVER")))
*classdriver = &driverTracker[i];
else
/* it is not a CCID Class driver */
driver = &driverTracker[i];
}
}
/* if we found a specific driver */
if (driver)
return driver;
/* else return the Class driver (if any) */
return *classdriver;
}
static void
do_list_local ()
{
struct udev *udev;
struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry;
struct udev_device *dev;
const gchar *path;
const gchar *idVendor;
const gchar *idProduct;
const gchar *bConfValue;
const gchar *bNumIntfs;
const gchar *busid;
/* Create libudev context. */
udev = udev_new ();
/* Create libudev device enumeration. */
enumerate = udev_enumerate_new (udev);
/* Take only USB devices that are not hubs and do not have
* the bInterfaceNumber attribute, i.e. are not interfaces.
*/
udev_enumerate_add_match_subsystem (enumerate, "usb");
udev_enumerate_add_nomatch_sysattr (enumerate, "bDeviceClass", "09");
udev_enumerate_add_nomatch_sysattr (enumerate, "bInterfaceNumber", NULL);
udev_enumerate_scan_devices (enumerate);
devices = udev_enumerate_get_list_entry (enumerate);
/* Show information about each device. */
udev_list_entry_foreach (dev_list_entry, devices) {
path = udev_list_entry_get_name (dev_list_entry);
dev = udev_device_new_from_syspath (udev, path);
/* Get device information. */
idVendor = udev_device_get_sysattr_value (dev, "idVendor");
idProduct = udev_device_get_sysattr_value (dev, "idProduct");
bConfValue = udev_device_get_sysattr_value (dev, "bConfigurationValue");
bNumIntfs = udev_device_get_sysattr_value (dev, "bNumInterfaces");
busid = udev_device_get_sysname (dev);
if (!idVendor || !idProduct || !bConfValue || !bNumIntfs) {
g_printerr ("problem getting device attributes: %s\n",
g_strerror (errno));
break;
}
g_print (" - busid %s (%.4s:%.4s)\n\n", busid, idVendor, idProduct);
udev_device_unref (dev);
}
// Add a udev device. Returns 0 if device was recognized/added.
static int usb_add_device(struct udev_device* dev){
const char* vendor = udev_device_get_sysattr_value(dev, "idVendor");
if(vendor && !strcmp(vendor, V_CORSAIR_STR)){
const char* product = udev_device_get_sysattr_value(dev, "idProduct");
if(product){
for(_model* model = models; model < models + N_MODELS; model++){
if(!strcmp(product, model->name)){
return usbadd(dev, V_CORSAIR, model->number);
}
}
}
}
return 1;
}
/* retrieve on-board index number and label from firmware */
static int dev_pci_onboard(struct udev_device *dev, struct netnames *names) {
unsigned dev_port = 0;
size_t l;
char *s;
const char *attr, *port_name;
int idx;
/* ACPI _DSM — device specific method for naming a PCI or PCI Express device */
attr = udev_device_get_sysattr_value(names->pcidev, "acpi_index");
/* SMBIOS type 41 — Onboard Devices Extended Information */
if (!attr)
attr = udev_device_get_sysattr_value(names->pcidev, "index");
if (!attr)
return -ENOENT;
idx = strtoul(attr, NULL, 0);
if (idx <= 0)
return -EINVAL;
/* Some BIOSes report rubbish indexes that are excessively high (2^24-1 is an index VMware likes to report for
* example). Let's define a cut-off where we don't consider the index reliable anymore. We pick some arbitrary
* cut-off, which is somewhere beyond the realistic number of physical network interface a system might
* have. Ideally the kernel would already filter his crap for us, but it doesn't currently. */
if (idx > ONBOARD_INDEX_MAX)
return -ENOENT;
/* kernel provided port index for multiple ports on a single PCI function */
attr = udev_device_get_sysattr_value(dev, "dev_port");
if (attr)
dev_port = strtol(attr, NULL, 10);
/* kernel provided front panel port name for multiple port PCI device */
port_name = udev_device_get_sysattr_value(dev, "phys_port_name");
s = names->pci_onboard;
l = sizeof(names->pci_onboard);
l = strpcpyf(&s, l, "o%d", idx);
if (port_name)
l = strpcpyf(&s, l, "n%s", port_name);
else if (dev_port > 0)
l = strpcpyf(&s, l, "d%d", dev_port);
if (l == 0)
names->pci_onboard[0] = '\0';
names->pci_onboard_label = udev_device_get_sysattr_value(names->pcidev, "label");
return 0;
}
/* This function allocates memory from the heap for the property
* value. That memory must be later freed by some other code. */
static int udevGetDeviceSysfsAttr(struct udev_device *udev_device,
const char *attr_name,
char **attr_value)
{
const char *udev_value = NULL;
int ret = PROPERTY_FOUND;
udev_value = udev_device_get_sysattr_value(udev_device, attr_name);
if (udev_value == NULL) {
VIR_DEBUG("udev reports device '%s' does not have sysfs attr '%s'",
udev_device_get_sysname(udev_device), attr_name);
ret = PROPERTY_MISSING;
goto out;
}
/* If this allocation is changed, the comment at the beginning
* of the function must also be changed. */
*attr_value = strdup(udev_value);
if (*attr_value == NULL) {
VIR_ERROR(_("Failed to allocate memory for sysfs attribute value for "
"sysfs attribute '%s' on device with sysname '%s'"),
attr_name, udev_device_get_sysname(udev_device));
virReportOOMError();
ret = PROPERTY_ERROR;
goto out;
}
VIR_DEBUG("Found sysfs attribute '%s' value '%s' "
"for device with sysname '%s'",
attr_name, *attr_value,
udev_device_get_sysname(udev_device));
out:
return ret;
}
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 refresh_imported_device_list(void)
{
const char *attr_status;
char status[MAX_STATUS_NAME+1] = "status";
int i, ret;
for (i = 0; i < vhci_driver->ncontrollers; i++) {
if (i > 0)
snprintf(status, sizeof(status), "status.%d", i);
attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
status);
if (!attr_status) {
err("udev_device_get_sysattr_value failed");
return -1;
}
dbg("controller %d", i);
ret = parse_status(attr_status);
if (ret != 0)
return ret;
}
return 0;
}
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;
}
void udevenum(){
struct udev_enumerate* enumerator = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerator, "usb");
udev_enumerate_add_match_sysattr(enumerator, "idVendor", V_CORSAIR_STR);
udev_enumerate_scan_devices(enumerator);
struct udev_list_entry* devices, *dev_list_entry;
devices = udev_enumerate_get_list_entry(enumerator);
udev_list_entry_foreach(dev_list_entry, devices){
const char* path = udev_list_entry_get_name(dev_list_entry);
struct udev_device* dev = udev_device_new_from_syspath(udev, path);
// If the device matches a recognized device ID, open it
const char* product = udev_device_get_sysattr_value(dev, "idProduct");
if(!strcmp(product, P_K70_STR)){
pthread_mutex_lock(&kblistmutex);
openusb(dev, 70);
pthread_mutex_unlock(&kblistmutex);
continue;
}
if(!strcmp(product, P_K95_STR)){
pthread_mutex_lock(&kblistmutex);
openusb(dev, 95);
pthread_mutex_unlock(&kblistmutex);
continue;
}
// Free the device if it wasn't used
udev_device_unref(dev);
}
udev_enumerate_unref(enumerator);
}
/**
* Walks up the device chain starting at @p syspath,
* checking each device for @p sysattr, and returns the value if found.
*
* @param syspath The /sys/ path of the device to start at, with or without the /sys/
* @param sysattr The attribute to find
*
* @return The stringshared value of @p sysattr if found, or NULL
*/
EAPI const char *
eeze_udev_walk_get_sysattr(const char *syspath,
const char *sysattr)
{
_udev_device *device, *child, *parent;
const char *test = NULL;
if (!syspath)
return NULL;
if (!(device = _new_device(syspath)))
return NULL;
for (parent = device; parent;
child = parent, parent = udev_device_get_parent(child))
{
if ((test = udev_device_get_sysattr_value(parent, sysattr)))
{
test = eina_stringshare_add(test);
udev_device_unref(device);
return test;
}
}
udev_device_unref(device);
return NULL;
}
/**
* @brief Get the MAC address of a net object
* @param net The net object
* @return The MAC address, NULL on failure
* Use this function to retrieve the non-stringshared MAC address of @p net.
*/
const char *
eeze_net_mac_get(Eeze_Net *net)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(net, NULL);
return udev_device_get_sysattr_value(net->device, "address");
}
static gboolean setup_isi_serial(struct modem_info* modem)
{
struct serial_device_info* info;
const char *value;
info = modem->serial;
if (g_strcmp0(udev_device_get_subsystem(info->dev), "net") != 0)
return FALSE;
value = udev_device_get_sysattr_value(info->dev, "type");
if (g_strcmp0(value, "820") != 0)
return FALSE;
/* OK, we want this device to be a modem */
value = udev_device_get_sysname(info->dev);
if (value)
ofono_modem_set_string(modem->modem, "Interface", value);
value = udev_device_get_property_value(info->dev, "OFONO_ISI_ADDRESS");
if (value)
ofono_modem_set_integer(modem->modem, "Address", atoi(value));
ofono_modem_set_string(modem->modem, "Device", info->devnode);
return TRUE;
}
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 get_nports(void)
{
char *c;
int nports = 0;
const char *attr_status;
attr_status = udev_device_get_sysattr_value(vhci_driver->hc_device,
"status");
if (!attr_status) {
err("udev_device_get_sysattr_value failed");
return -1;
}
/* skip a header line */
c = strchr(attr_status, '\n');
if (!c)
return 0;
c++;
while (*c != '\0') {
/* go to the next line */
c = strchr(c, '\n');
if (!c)
return nports;
c++;
nports += 1;
}
return nports;
}
int fs_on_read_only(const char *p) {
struct stat st;
struct udev *udev = NULL;
struct udev_device *udev_device = NULL;
bool b = false;
const char *read_only;
assert(p);
if (stat(p, &st) < 0)
return -errno;
if (major(st.st_dev) == 0)
return false;
if (!(udev = udev_new()))
return -ENOMEM;
if (!(udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev)))
goto finish;
if ((read_only = udev_device_get_sysattr_value(udev_device, "ro")))
if ((b = streq(read_only, "1")))
goto finish;
finish:
if (udev_device)
udev_device_unref(udev_device);
if (udev)
udev_unref(udev);
return b;
}
/**
* get_rfkill_device_by_index:
**/
struct udev_device *
get_rfkill_device_by_index (struct udev *udev,
guint index)
{
struct udev_enumerate *enumerate;
struct udev_list_entry *devices;
struct udev_list_entry *dev_list_entry;
struct udev_device *dev;
enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "rfkill");
udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) {
const char *path, *index_c;
path = udev_list_entry_get_name(dev_list_entry);
dev = udev_device_new_from_syspath(udev, path);
index_c = udev_device_get_sysattr_value (dev, "index");
if (index_c && atoi(index_c) == index)
break;
udev_device_unref (dev);
dev = NULL;
}
return dev;
}
static int _udev_check_pv_min_size(struct device *dev)
{
struct dev_ext *ext;
const char *size_str;
char *endp;
uint64_t size;
if (!(ext = dev_ext_get(dev)))
return_0;
if (!(size_str = udev_device_get_sysattr_value((struct udev_device *)ext->handle, DEV_EXT_UDEV_SYSFS_ATTR_SIZE))) {
log_debug_devs("%s: Skipping: failed to get size from sysfs [%s:%p]",
dev_name(dev), dev_ext_name(dev), dev->ext.handle);
return 0;
}
errno = 0;
size = strtoull(size_str, &endp, 10);
if (errno || !endp || *endp) {
log_debug_devs("%s: Skipping: failed to parse size from sysfs [%s:%p]",
dev_name(dev), dev_ext_name(dev), dev->ext.handle);
return 0;
}
if (size < pv_min_size()) {
log_debug_devs("%s: Skipping: %s [%s:%p]", dev_name(dev),
_too_small_to_hold_pv_msg,
dev_ext_name(dev), dev->ext.handle);
return 0;
}
return 1;
}
int fs_on_read_only(const char *p) {
struct stat st;
_cleanup_udev_unref_ struct udev *udev = NULL;
_cleanup_udev_device_unref_ struct udev_device *udev_device = NULL;
const char *read_only;
assert(p);
if (stat(p, &st) < 0)
return -errno;
if (major(st.st_dev) == 0)
return false;
udev = udev_new();
if (!udev)
return -ENOMEM;
udev_device = udev_device_new_from_devnum(udev, 'b', st.st_dev);
if (!udev_device)
return false;
read_only = udev_device_get_sysattr_value(udev_device, "ro");
if (read_only)
return streq(read_only, "1");
return false;
}
/**
* Walks up the device chain starting at @p syspath,
* checking each device for @p sysattr with (optional) @p value.
*
* @param syspath The /sys/ path of the device to start at, with or without the /sys/
* @param sysattr The attribute to find
* @param value OPTIONAL: The value that @p sysattr should have, or NULL
*
* @return If the sysattr (with value) is found, returns TRUE. Else, false.
*/
EAPI Eina_Bool
eeze_udev_walk_check_sysattr(const char *syspath,
const char *sysattr,
const char *value)
{
_udev_device *device, *child, *parent;
Eina_Bool ret = EINA_FALSE;
const char *test = NULL;
if (!udev)
return EINA_FALSE;
if (!(device = _new_device(syspath)))
return EINA_FALSE;
for (parent = device; parent;
child = parent, parent = udev_device_get_parent(child))
{
if (!(test = udev_device_get_sysattr_value(parent, sysattr)))
continue;
if ((value && (!strcmp(test, value))) || (!value))
{
ret = EINA_TRUE;
break;
}
}
udev_device_unref(device);
return ret;
}
static void print_all_attributes(struct udev_device *device, const char *key) {
struct udev_list_entry *sysattr;
udev_list_entry_foreach(sysattr, udev_device_get_sysattr_list_entry(device)) {
const char *name;
const char *value;
size_t len;
name = udev_list_entry_get_name(sysattr);
if (skip_attribute(name))
continue;
value = udev_device_get_sysattr_value(device, name);
if (value == NULL)
continue;
/* skip any values that look like a path */
if (value[0] == '/')
continue;
/* skip nonprintable attributes */
len = strlen(value);
while (len > 0 && isprint(value[len-1]))
len--;
if (len > 0)
continue;
printf(" %s{%s}==\"%s\"\n", key, name, value);
}
printf("\n");
}
static virInterfacePtr
udevInterfaceLookupByName(virConnectPtr conn, const char *name)
{
struct udev_iface_driver *driverState = conn->interfacePrivateData;
struct udev *udev = udev_ref(driverState->udev);
struct udev_device *dev;
const char *macaddr;
virInterfacePtr ret = NULL;
/* get a device reference based on the device name */
dev = udev_device_new_from_subsystem_sysname(udev, "net", name);
if (!dev) {
virReportError(VIR_ERR_NO_INTERFACE,
_("couldn't find interface named '%s'"),
name);
goto err;
}
macaddr = udev_device_get_sysattr_value(dev, "address");
ret = virGetInterface(conn, name, macaddr);
udev_device_unref(dev);
err:
udev_unref(udev);
return ret;
}