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;
}
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;
virInterfacePtr ret = NULL;
virInterfaceDefPtr def = 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 cleanup;
}
if (!(def = udevGetMinimalDefForDevice(dev)))
goto cleanup;
if (virInterfaceLookupByNameEnsureACL(conn, def) < 0)
goto cleanup;
ret = virGetInterface(conn, def->name, def->mac);
udev_device_unref(dev);
cleanup:
udev_unref(udev);
virInterfaceDefFree(def);
return ret;
}
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;
}
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;
}
//Search for all optical drives
void pup_cd_drive_get_all(PupVMMonitor *monitor)
{
GDir *block_dir;
GError *error = NULL;
g_debug("Init time scanning");
block_dir = g_dir_open("/sys/block", 0, &error);
if (error)
{
g_critical("Couldn't open /sys/block: %s", error->message);
g_clear_error(&error);
}
struct udev *udev_ctx = udev_new();
gchar *one_sysname;
while ((one_sysname = (gchar *) g_dir_read_name(block_dir)))
{
struct udev_device *dev = udev_device_new_from_subsystem_sysname
(udev_ctx, "block", one_sysname);
if (dev)
{
g_debug("Testing %s", one_sysname);
if (pup_drive_test_optical(dev))
{
g_debug("Success, now adding to monitor");
pup_cd_drive_new_from_udev_device(monitor, dev);
}
udev_device_unref(dev);
}
}
udev_unref(udev_ctx);
g_dir_close(block_dir);
}
int read_usb_interface(struct usbip_usb_device *udev, int i,
struct usbip_usb_interface *uinf)
{
char busid[SYSFS_BUS_ID_SIZE];
int size;
struct udev_device *sif;
size = snprintf(busid, sizeof(busid), "%s:%d.%d",
udev->busid, udev->bConfigurationValue, i);
if (size < 0 || (unsigned int)size >= sizeof(busid)) {
err("busid length %i >= %lu or < 0", size,
(long unsigned)sizeof(busid));
return -1;
}
sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid);
if (!sif) {
err("udev_device_new_from_subsystem_sysname %s failed", busid);
return -1;
}
READ_ATTR(uinf, uint8_t, sif, bInterfaceClass, "%02x\n");
READ_ATTR(uinf, uint8_t, sif, bInterfaceSubClass, "%02x\n");
READ_ATTR(uinf, uint8_t, sif, bInterfaceProtocol, "%02x\n");
return 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;
}
/**
* 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;
}
/*
* Usage: devname2devid <devicepath>
*
* Examples:
* # ./devname2devid /dev/sda1
* devid scsi-350000394a8caede4-part1
*
* # ./devname2devid /dev/dm-1
* devid: 'dm-uuid-mpath-35000c5006304de3f'
*
* This program accepts a disk or disk slice path and prints a
* device id.
*
* Exit values:
* 0 - means success
* 1 - means failure
*
*/
int
main(int argc, char *argv[])
{
struct udev *udev;
struct udev_device *dev = NULL;
char devid[128], nodepath[MAXPATHLEN];
char *device, *sysname;
int ret;
if (argc == 1) {
(void) printf("%s <devicepath> [search path]\n", argv[0]);
exit(1);
}
device = argv[1];
if ((udev = udev_new()) == NULL) {
perror("udev_new");
exit(1);
}
/* resolve path to a runtime device node instance */
if (realpath(device, nodepath) == NULL) {
perror("realpath");
exit(1);
}
sysname = strrchr(nodepath, '/') + 1;
if ((dev = udev_device_new_from_subsystem_sysname(udev, "block",
sysname)) == NULL) {
perror(sysname);
exit(1);
}
if ((ret = udev_device_get_devid(dev, devid, sizeof (devid))) != 0) {
udev_device_unref(dev);
errno = ret;
perror(sysname);
exit(1);
}
(void) printf("devid %s\n", devid);
udev_device_unref(dev);
udev_unref(udev);
return (0);
}
static int
udev_initialized(const char *ifname)
{
struct udev_device *device;
int r;
device = udev_device_new_from_subsystem_sysname(udev, "net", ifname);
if (device) {
#ifndef LIBUDEV_NOINIT
r = udev_device_get_is_initialized(device);
#else
r = 1;
#endif
udev_device_unref(device);
} else
r = 0;
return r;
}
static char *disk_udev_attr_name (struct udev *udev, char *disk_name, const char *attr)
{
struct udev_device *dev;
const char *prop;
char *output = NULL;
dev = udev_device_new_from_subsystem_sysname (udev, "block", disk_name);
if (dev != NULL)
{
prop = udev_device_get_property_value (dev, attr);
if (prop) {
output = strdup (prop);
DEBUG ("disk plugin: renaming %s => %s", disk_name, output);
}
udev_device_unref (dev);
}
return output;
}
static struct usbip_imported_device *
imported_device_init(struct usbip_imported_device *idev, char *busid)
{
struct udev_device *sudev;
sudev = udev_device_new_from_subsystem_sysname(udev_context,
"usb", busid);
if (!sudev) {
dbg("udev_device_new_from_subsystem_sysname failed: %s", busid);
goto err;
}
read_usb_device(sudev, &idev->udev);
udev_device_unref(sudev);
return idev;
err:
return NULL;
}
static int bind_device(char *busid)
{
int rc;
struct udev *udev;
struct udev_device *dev;
/* Check whether the device with this bus ID exists. */
udev = udev_new();
dev = udev_device_new_from_subsystem_sysname(udev, "usb", busid);
if (!dev) {
err("device with the specified bus ID does not exist");
return -1;
}
udev_unref(udev);
rc = unbind_other(busid);
if (rc == UNBIND_ST_FAILED) {
err("could not unbind driver from device on busid %s", busid);
return -1;
} else if (rc == UNBIND_ST_USBIP_HOST) {
err("device on busid %s is already bound to %s", busid,
USBIP_HOST_DRV_NAME);
return -1;
}
rc = modify_match_busid(busid, 1);
if (rc < 0) {
err("unable to bind device on %s", busid);
return -1;
}
rc = bind_usbip(busid);
if (rc < 0) {
err("could not bind device to %s", USBIP_HOST_DRV_NAME);
modify_match_busid(busid, 0);
return -1;
}
info("bind device on busid %s: complete", busid);
return 0;
}
int read_usb_interface(struct usbip_usb_device *udev, int i,
struct usbip_usb_interface *uinf)
{
char busid[SYSFS_BUS_ID_SIZE];
struct udev_device *sif;
sprintf(busid, "%s:%d.%d", udev->busid, udev->bConfigurationValue, i);
sif = udev_device_new_from_subsystem_sysname(udev_context, "usb", busid);
if (!sif) {
err("udev_device_new_from_subsystem_sysname %s failed", busid);
return -1;
}
READ_ATTR(uinf, uint8_t, sif, bInterfaceClass, "%02x\n");
READ_ATTR(uinf, uint8_t, sif, bInterfaceSubClass, "%02x\n");
READ_ATTR(uinf, uint8_t, sif, bInterfaceProtocol, "%02x\n");
return 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_DRV_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 (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;
}
void fillDesk(void)
{
struct udev *udev;
udev_device *thedev;
udev_device *usbdev;
char buffer[BUFFERSIZE];
char path[BUFFERSIZE];
char *uuid=NULL;
int iconhint=0;
bool iscd=false;
bool isdvd=false;
bool isusb=false;
FILE *fp;
const char *ptr;
char *holdfilename=NULL;
/* Create the udev object */
udev = udev_new();
if (!udev) {
printf("Can't create udev\n");
exit(1);
}
deskIconsCnt=RESERVED;
fp=popen("ls -1 /dev/disk/by-uuid","r");
if(fp!=NULL)
{
buffer[0]=0;
while(fgets(buffer,BUFFERSIZE,fp))
{
addExtraIconSpace();
clearDeskEntry(deskIconsCnt,false);
buffer[strlen(buffer)-1]=0;
asprintf(&uuid,"%s",buffer);
sprintf(path,"/dev/disk/by-uuid/%s",buffer);
buffer[readlink(path,buffer,BUFFERSIZE)]=0;
ptr=strrchr(buffer,'/');
ptr++;
sprintf(path,"/dev/%s",ptr);
if(strcmp(path,rootDev)==0)
continue;
deskIconsArray[deskIconsCnt].partname=strdup(ptr);
thedev=udev_device_new_from_subsystem_sysname(udev,"block",ptr);
if(thedev==NULL)
{
printf("no dev for %s from %s\n",ptr,buffer);
exit(1);
}
else
{
if(strcmp(udev_device_get_property_value(thedev,"ID_FS_USAGE"),"filesystem")==0)
{
ptr=udev_device_get_property_value(thedev,"ID_FS_LABEL");
if(ptr==NULL)
ptr=udev_device_get_property_value(thedev,"ID_SERIAL");
if(ptr==NULL)
continue;
iconhint=0;
deskIconsArray[deskIconsCnt].label=strdup(ptr);
deskIconsArray[deskIconsCnt].uuid=uuid;
isdvd=false;
iscd=false;
isusb=false;
if(udev_device_get_property_value(thedev,"ID_CDROM_MEDIA_DVD")!=NULL)
{
iconhint=DVD;
isdvd=true;
}
if(udev_device_get_property_value(thedev,"ID_CDROM_MEDIA_CD")!=NULL)
{
iconhint=CDROM;
iscd=true;
}
usbdev=udev_device_get_parent_with_subsystem_devtype(thedev,"usb","usb_device");
if(usbdev!=NULL)
{
isusb=true;
if(udev_device_get_property_value(thedev,"ID_DRIVE_THUMB")!=NULL)
iconhint=STICK;
else
iconhint=getUSBData(udev_device_get_property_value(thedev,"ID_VENDOR"));
}
asprintf(&deskIconsArray[deskIconsCnt].dev,"/dev/%s",deskIconsArray[deskIconsCnt].partname);
deskIconsArray[deskIconsCnt].dvd=isdvd;
deskIconsArray[deskIconsCnt].cdrom=iscd;
deskIconsArray[deskIconsCnt].usb=isusb;
deskIconsArray[deskIconsCnt].file=false;
deskIconsArray[deskIconsCnt].iconhint=iconhint;
if(ignores!=NULL)
{
if(strstr(ignores,deskIconsArray[deskIconsCnt].label)!=NULL)
deskIconsArray[deskIconsCnt].ignore=true;
}
sprintf(buffer,"%s/%s",diskInfoPath,deskIconsArray[deskIconsCnt].uuid);
if(loadVarsFromFile(buffer,globalFileData))
{
deskIconsArray[deskIconsCnt].x=fileDiskXPos;
deskIconsArray[deskIconsCnt].y=fileDiskYPos;
if(fileGotCustomIcon==true)
{
deskIconsArray[deskIconsCnt].icon=fileCustomIcon;
deskIconsArray[deskIconsCnt].customicon=true;
fileCustomIcon=NULL;
fileGotCustomIcon=false;
}
else
deskIconsArray[deskIconsCnt].icon=NULL;
}
else
{
getFreeSlot(&deskIconsArray[deskIconsCnt].x,&deskIconsArray[deskIconsCnt].y);
saveInfofile(DISKFOLDER,deskIconsArray[deskIconsCnt].label,NULL,NULL,deskIconsArray[deskIconsCnt].uuid,(char*)iconDiskType[deskIconsArray[deskIconsCnt].iconhint],deskIconsArray[deskIconsCnt].x,deskIconsArray[deskIconsCnt].y,deskIconsCnt);
}
deskIconsArray[deskIconsCnt].installed=true;
xySlot[deskIconsArray[deskIconsCnt].x][deskIconsArray[deskIconsCnt].y]=1;
deskIconsCnt++;
}
}
}
}
pclose(fp);
holdfilename=NULL;
//desktop files
sprintf(buffer,"find %s -mindepth 1 -maxdepth 1",desktopPath);
char buffer2[4096];
char *tptr;
fp=popen(buffer,"r");
while(fgets(buffer,BUFFERSIZE,fp))
{
char *ptr;
buffer[strlen(buffer)-1]=0;
ptr=strrchr(buffer,'/');
ptr++;
sprintf(buffer2,"%s/%s",cachePath,ptr);
addExtraIconSpace();
if(strcmp(&buffer[strlen(buffer)-8],".desktop")==0)
{
holdfilename=strdup(buffer);
}
if(fileExists(buffer2)==-1)
{
clearDeskEntry(deskIconsCnt,false);
deskIconsArray[deskIconsCnt].mountpoint=strdup(buffer);
ptr=strrchr(buffer,'/');
ptr++;
deskIconsArray[deskIconsCnt].label=strdup(ptr);
tptr=getMimeType(buffer);
ptr=strchr(tptr,'/');
while(ptr!=NULL)
{
*ptr='-';
ptr=strchr(tptr,'/');
}
ptr=strstr(tptr,"text-x-shellscript");
if(ptr==NULL)
deskIconsArray[deskIconsCnt].mime=strdup(tptr);
else
deskIconsArray[deskIconsCnt].mime=strdup("application-x-shellscript");
free(tptr);
getFreeSlot(&deskIconsArray[deskIconsCnt].x,&deskIconsArray[deskIconsCnt].y);
xySlot[deskIconsArray[deskIconsCnt].x][deskIconsArray[deskIconsCnt].y]=1;
saveInfofile(CACHEFOLDER,deskIconsArray[deskIconsCnt].label,deskIconsArray[deskIconsCnt].mime,deskIconsArray[deskIconsCnt].mountpoint,NULL,NULL,deskIconsArray[deskIconsCnt].x,deskIconsArray[deskIconsCnt].y,deskIconsCnt);
deskIconsArray[deskIconsCnt].installed=true;
deskIconsArray[deskIconsCnt].file=true;
deskIconsCnt++;
}
else
{
readDesktopFile(ptr);
}
if((holdfilename!=NULL) && (deskIconsArray[deskIconsCnt-1].customicon==false))
{
char commandbuffer[MAXBUFFER];
char *icon;
char *pth;
sprintf(commandbuffer,"awk -F= '/Icon=/{print $2}' \"%s\"",holdfilename);
icon=oneLiner("%s",commandbuffer);
pth=strrchr(icon,'.');
if(pth!=NULL)
*pth=0;
if(icon!=NULL)
{
pth=pathToIcon(icon,"");
deskIconsArray[deskIconsCnt-1].icon=strdup(pth);
}
free(holdfilename);
holdfilename=NULL;
fileCustomIcon=NULL;
}
}
pclose(fp);
}
/* handle "[<SUBSYSTEM>/<KERNEL>]<attribute>" format */
int util_resolve_subsys_kernel(struct udev *udev, const char *string,
char *result, size_t maxsize, int read_value)
{
char temp[UTIL_PATH_SIZE];
char *subsys;
char *sysname;
struct udev_device *dev;
char *attr;
if (string[0] != '[')
return -1;
util_strscpy(temp, sizeof(temp), string);
subsys = &temp[1];
sysname = strchr(subsys, '/');
if (sysname == NULL)
return -1;
sysname[0] = '\0';
sysname = &sysname[1];
attr = strchr(sysname, ']');
if (attr == NULL)
return -1;
attr[0] = '\0';
attr = &attr[1];
if (attr[0] == '/')
attr = &attr[1];
if (attr[0] == '\0')
attr = NULL;
if (read_value && attr == NULL)
return -1;
dev = udev_device_new_from_subsystem_sysname(udev, subsys, sysname);
if (dev == NULL)
return -1;
if (read_value) {
const char *val;
val = udev_device_get_sysattr_value(dev, attr);
if (val != NULL)
util_strscpy(result, maxsize, val);
else
result[0] = '\0';
info(udev, "value '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
} else {
size_t l;
char *s;
s = result;
l = util_strpcpyl(&s, maxsize, udev_device_get_syspath(dev), NULL);
if (attr != NULL)
util_strpcpyl(&s, l, "/", attr, NULL);
info(udev, "path '[%s/%s]%s' is '%s'\n", subsys, sysname, attr, result);
}
udev_device_unref(dev);
return 0;
}
static int dev_pci_slot(struct udev_device *dev, struct netnames *names) {
struct udev *udev = udev_device_get_udev(names->pcidev);
unsigned domain, bus, slot, func, dev_port = 0;
size_t l;
char *s;
const char *attr;
struct udev_device *pci = NULL;
char slots[256], str[256];
_cleanup_closedir_ DIR *dir = NULL;
struct dirent *dent;
int hotplug_slot = 0, err = 0;
if (sscanf(udev_device_get_sysname(names->pcidev), "%x:%x:%x.%u", &domain, &bus, &slot, &func) != 4)
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);
/* compose a name based on the raw kernel's PCI bus, slot numbers */
s = names->pci_path;
l = sizeof(names->pci_path);
if (domain > 0)
l = strpcpyf(&s, l, "P%u", domain);
l = strpcpyf(&s, l, "p%us%u", bus, slot);
if (func > 0 || is_pci_multifunction(names->pcidev))
l = strpcpyf(&s, l, "f%u", func);
if (dev_port > 0)
l = strpcpyf(&s, l, "d%u", dev_port);
if (l == 0)
names->pci_path[0] = '\0';
/* ACPI _SUN — slot user number */
pci = udev_device_new_from_subsystem_sysname(udev, "subsystem", "pci");
if (!pci) {
err = -ENOENT;
goto out;
}
xsprintf(slots, "%s/slots", udev_device_get_syspath(pci));
dir = opendir(slots);
if (!dir) {
err = -errno;
goto out;
}
for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
int i;
char *rest;
char *address;
if (dent->d_name[0] == '.')
continue;
i = strtol(dent->d_name, &rest, 10);
if (rest[0] != '\0')
continue;
if (i < 1)
continue;
xsprintf(str, "%s/%s/address", slots, dent->d_name);
if (read_one_line_file(str, &address) >= 0) {
/* match slot address with device by stripping the function */
if (strneq(address, udev_device_get_sysname(names->pcidev), strlen(address)))
hotplug_slot = i;
free(address);
}
if (hotplug_slot > 0)
break;
}
if (hotplug_slot > 0) {
s = names->pci_slot;
l = sizeof(names->pci_slot);
if (domain > 0)
l = strpcpyf(&s, l, "P%d", domain);
l = strpcpyf(&s, l, "s%d", hotplug_slot);
if (func > 0 || is_pci_multifunction(names->pcidev))
l = strpcpyf(&s, l, "f%d", func);
if (dev_port > 0)
l = strpcpyf(&s, l, "d%d", dev_port);
if (l == 0)
names->pci_slot[0] = '\0';
}
out:
udev_device_unref(pci);
return err;
}
/* buggy driver may cause dead lock */
static int unbind_other(char *busid)
{
enum unbind_status status = UNBIND_ST_OK;
char attr_name[] = "unbind";
char unbind_attr_path[SYSFS_PATH_MAX];
int rc = -1;
struct udev *udev;
struct udev_device *dev;
const char *driver;
const char *bDevClass;
/* Create libudev context. */
udev = udev_new();
/* Get the device. */
dev = udev_device_new_from_subsystem_sysname(udev, "usb", busid);
if (!dev) {
dbg("unable to find device with bus ID %s", busid);
goto err_close_busid_dev;
}
/* Check what kind of device it is. */
bDevClass = udev_device_get_sysattr_value(dev, "bDeviceClass");
if (!bDevClass) {
dbg("unable to get bDevClass device attribute");
goto err_close_busid_dev;
}
if (!strncmp(bDevClass, "09", strlen(bDevClass))) {
dbg("skip unbinding of hub");
goto err_close_busid_dev;
}
/* Get the device driver. */
driver = udev_device_get_driver(dev);
if (!driver) {
/* No driver bound to this device. */
goto out;
}
if (!strncmp(USBIP_HOST_DRV_NAME, driver,
strlen(USBIP_HOST_DRV_NAME))) {
/* Already bound to usbip-host. */
status = UNBIND_ST_USBIP_HOST;
goto out;
}
/* Unbind device from driver. */
snprintf(unbind_attr_path, sizeof(unbind_attr_path), "%s/%s/%s/%s/%s/%s",
SYSFS_MNT_PATH, SYSFS_BUS_NAME, SYSFS_BUS_TYPE,
SYSFS_DRIVERS_NAME, driver, attr_name);
rc = write_sysfs_attribute(unbind_attr_path, busid, strlen(busid));
if (rc < 0) {
err("error unbinding device %s from driver", busid);
goto err_close_busid_dev;
}
goto out;
err_close_busid_dev:
status = UNBIND_ST_FAILED;
out:
udev_device_unref(dev);
udev_unref(udev);
return status;
}
static int unbind_device(char *busid)
{
char bus_type[] = "usb";
int rc, ret = -1;
char unbind_attr_name[] = "unbind";
char unbind_attr_path[SYSFS_PATH_MAX];
char rebind_attr_name[] = "rebind";
char rebind_attr_path[SYSFS_PATH_MAX];
struct udev *udev;
struct udev_device *dev;
const char *driver;
/* Create libudev context. */
udev = udev_new();
/* Check whether the device with this bus ID exists. */
dev = udev_device_new_from_subsystem_sysname(udev, "usb", busid);
if (!dev) {
err("device with the specified bus ID does not exist");
goto err_close_udev;
}
/* Check whether the device is using usbip-host driver. */
driver = udev_device_get_driver(dev);
if (!driver || strcmp(driver, "usbip-host")) {
err("device is not bound to usbip-host driver");
goto err_close_udev;
}
/* Unbind device from driver. */
snprintf(unbind_attr_path, sizeof(unbind_attr_path), "%s/%s/%s/%s/%s/%s",
SYSFS_MNT_PATH, SYSFS_BUS_NAME, bus_type, SYSFS_DRIVERS_NAME,
USBIP_HOST_DRV_NAME, unbind_attr_name);
rc = write_sysfs_attribute(unbind_attr_path, busid, strlen(busid));
if (rc < 0) {
err("error unbinding device %s from driver", busid);
goto err_close_udev;
}
/* Notify driver of unbind. */
rc = modify_match_busid(busid, 0);
if (rc < 0) {
err("unable to unbind device on %s", busid);
goto err_close_udev;
}
/* Trigger new probing. */
snprintf(rebind_attr_path, sizeof(unbind_attr_path), "%s/%s/%s/%s/%s/%s",
SYSFS_MNT_PATH, SYSFS_BUS_NAME, bus_type, SYSFS_DRIVERS_NAME,
USBIP_HOST_DRV_NAME, rebind_attr_name);
rc = write_sysfs_attribute(rebind_attr_path, busid, strlen(busid));
if (rc < 0) {
err("error rebinding");
goto err_close_udev;
}
ret = 0;
info("unbind device on busid %s: complete", busid);
err_close_udev:
udev_device_unref(dev);
udev_unref(udev);
return ret;
}
static int dev_pci_slot(struct udev_device *dev, struct netnames *names) {
struct udev *udev = udev_device_get_udev(names->pcidev);
unsigned int bus;
unsigned int slot;
unsigned int func;
unsigned int dev_id = 0;
size_t l;
char *s;
const char *attr;
struct udev_device *pci = NULL;
char slots[256];
DIR *dir;
struct dirent *dent;
char str[256];
int hotplug_slot = 0;
int err = 0;
if (sscanf(udev_device_get_sysname(names->pcidev), "0000:%x:%x.%d", &bus, &slot, &func) != 3)
return -ENOENT;
/* kernel provided multi-device index */
attr = udev_device_get_sysattr_value(dev, "dev_id");
if (attr)
dev_id = strtol(attr, NULL, 16);
/* compose a name based on the raw kernel's PCI bus, slot numbers */
s = names->pci_path;
l = util_strpcpyf(&s, sizeof(names->pci_path), "p%ds%d", bus, slot);
if (func > 0 || is_pci_multifunction(names->pcidev))
l = util_strpcpyf(&s, l, "f%d", func);
if (dev_id > 0)
l = util_strpcpyf(&s, l, "d%d", dev_id);
if (l == 0)
names->pci_path[0] = '\0';
/* ACPI _SUN -- slot user number */
pci = udev_device_new_from_subsystem_sysname(udev, "subsystem", "pci");
if (!pci) {
err = -ENOENT;
goto out;
}
snprintf(slots, sizeof(slots), "%s/slots", udev_device_get_syspath(pci));
dir = opendir(slots);
if (!dir) {
err = -errno;
goto out;
}
for (dent = readdir(dir); dent != NULL; dent = readdir(dir)) {
int i;
char *rest;
char *address;
if (dent->d_name[0] == '.')
continue;
i = strtol(dent->d_name, &rest, 10);
if (rest[0] != '\0')
continue;
if (i < 1)
continue;
snprintf(str, sizeof(str), "%s/%s/address", slots, dent->d_name);
if (read_one_line_file(str, &address) >= 0) {
/* match slot address with device by stripping the function */
if (strncmp(address, udev_device_get_sysname(names->pcidev), strlen(address)) == 0)
hotplug_slot = i;
free(address);
}
if (hotplug_slot > 0)
break;
}
closedir(dir);
if (hotplug_slot > 0) {
s = names->pci_slot;
l = util_strpcpyf(&s, sizeof(names->pci_slot), "s%d", hotplug_slot);
if (func > 0 || is_pci_multifunction(names->pcidev))
l = util_strpcpyf(&s, l, "f%d", func);
if (dev_id > 0)
l = util_strpcpyf(&s, l, "d%d", dev_id);
if (l == 0)
names->pci_path[0] = '\0';
}
out:
udev_device_unref(pci);
return err;
}
int main(int argc, char *argv[]) {
struct udev *udev = NULL;
struct udev_device *device = NULL;
_cleanup_free_ char *saved = NULL;
int r;
if (argc != 3) {
log_error("This program requires two arguments.");
return EXIT_FAILURE;
}
log_set_target(LOG_TARGET_AUTO);
log_parse_environment();
log_open();
umask(0022);
r = mkdir_p("/var/lib/backlight", 0755);
if (r < 0) {
log_error("Failed to create backlight directory: %s", strerror(-r));
goto finish;
}
udev = udev_new();
if (!udev) {
r = log_oom();
goto finish;
}
errno = 0;
device = udev_device_new_from_subsystem_sysname(udev, "backlight", argv[2]);
if (!device) {
if (errno != 0) {
log_error("Failed to get backlight device: %m");
r = -errno;
} else
r = log_oom();
goto finish;
}
if (!streq_ptr(udev_device_get_subsystem(device), "backlight")) {
log_error("Not a backlight device: %s", argv[2]);
r = -ENODEV;
goto finish;
}
saved = strappend("/var/lib/backlight/", udev_device_get_sysname(device));
if (!saved) {
r = log_oom();
goto finish;
}
if (streq(argv[1], "load")) {
_cleanup_free_ char *value = NULL;
r = read_one_line_file(saved, &value);
if (r < 0) {
if (r == -ENOENT) {
r = 0;
goto finish;
}
log_error("Failed to read %s: %s", saved, strerror(-r));
goto finish;
}
r = udev_device_set_sysattr_value(device, "brightness", value);
if (r < 0) {
log_error("Failed to write system attribute: %s", strerror(-r));
goto finish;
}
} else if (streq(argv[1], "save")) {
const char *value;
value = udev_device_get_sysattr_value(device, "brightness");
if (!value) {
log_error("Failed to read system attribute: %s", strerror(-r));
goto finish;
}
r = write_string_file(saved, value);
if (r < 0) {
log_error("Failed to write %s: %s", saved, strerror(-r));
goto finish;
}
} else {
log_error("Unknown verb %s.", argv[1]);
r = -EINVAL;
goto finish;
}
finish:
if (device)
udev_device_unref(device);
if (udev)
udev_unref(udev);
return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
int main(int argc, char *argv[]) {
_cleanup_udev_unref_ struct udev *udev = NULL;
_cleanup_udev_device_unref_ struct udev_device *device = NULL;
_cleanup_free_ char *saved = NULL, *escaped_name = NULL, *escaped_path_id = NULL;
const char *name, *path_id;
int r;
if (argc != 3) {
log_error("This program requires two arguments.");
return EXIT_FAILURE;
}
log_set_target(LOG_TARGET_AUTO);
log_parse_environment();
log_open();
umask(0022);
r = mkdir_p("/var/lib/systemd/rfkill", 0755);
if (r < 0) {
log_error("Failed to create rfkill directory: %s", strerror(-r));
return EXIT_FAILURE;
}
udev = udev_new();
if (!udev) {
log_oom();
return EXIT_FAILURE;
}
errno = 0;
device = udev_device_new_from_subsystem_sysname(udev, "rfkill", argv[2]);
if (!device) {
if (errno != 0)
log_error("Failed to get rfkill device '%s': %m", argv[2]);
else
log_oom();
return EXIT_FAILURE;
}
name = udev_device_get_sysattr_value(device, "name");
if (!name) {
log_error("rfkill device has no name?");
return EXIT_FAILURE;
}
escaped_name = cescape(name);
if (!escaped_name) {
log_oom();
return EXIT_FAILURE;
}
path_id = udev_device_get_property_value(device, "ID_PATH");
if (path_id) {
escaped_path_id = cescape(path_id);
if (!escaped_path_id) {
log_oom();
return EXIT_FAILURE;
}
saved = strjoin("/var/lib/systemd/rfkill/", escaped_path_id, ":", escaped_name, NULL);
} else
saved = strjoin("/var/lib/systemd/rfkill/", escaped_name, NULL);
if (!saved) {
log_oom();
return EXIT_FAILURE;
}
if (streq(argv[1], "load") && restore_state()) {
_cleanup_free_ char *value = NULL;
r = read_one_line_file(saved, &value);
if (r < 0) {
if (r == -ENOENT)
return EXIT_SUCCESS;
log_error("Failed to read %s: %s", saved, strerror(-r));
return EXIT_FAILURE;
}
r = udev_device_set_sysattr_value(device, "soft", value);
if (r < 0) {
log_error("Failed to write system attribute: %s", strerror(-r));
return EXIT_FAILURE;
}
} else if (streq(argv[1], "save")) {
const char *value;
value = udev_device_get_sysattr_value(device, "soft");
if (!value) {
log_error("Failed to read system attribute: %s", strerror(-r));
return EXIT_FAILURE;
}
r = write_string_file(saved, value);
if (r < 0) {
log_error("Failed to write %s: %s", saved, strerror(-r));
return EXIT_FAILURE;
}
} else {
log_error("Unknown verb %s.", argv[1]);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int usbip_vhci_driver_open(void)
{
int nports;
struct udev_device *hc_device;
udev_context = udev_new();
if (!udev_context) {
err("udev_new failed");
return -1;
}
/* will be freed in usbip_driver_close() */
hc_device =
udev_device_new_from_subsystem_sysname(udev_context,
USBIP_VHCI_BUS_TYPE,
USBIP_VHCI_DEVICE_NAME);
if (!hc_device) {
err("udev_device_new_from_subsystem_sysname failed");
goto err;
}
nports = get_nports(hc_device);
if (nports <= 0) {
err("no available ports");
goto err;
}
dbg("available ports: %d", nports);
vhci_driver = calloc(1, sizeof(struct usbip_vhci_driver) +
nports * sizeof(struct usbip_imported_device));
if (!vhci_driver) {
err("vhci_driver allocation failed");
goto err;
}
vhci_driver->nports = nports;
vhci_driver->hc_device = hc_device;
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(hc_device);
if (vhci_driver)
free(vhci_driver);
vhci_driver = NULL;
udev_unref(udev_context);
return -1;
}
