UsbDevice *
usbFindDevice (UsbDeviceChooser chooser, void *data) {
int result;
UsbDeviceExtension *devx;
if (!usbContext) {
if ((result = libusb_init(&usbContext)) != LIBUSB_SUCCESS) {
usbSetErrno(result, "libusb_init");
return NULL;
}
}
if (!usbDeviceList) {
ssize_t count;
if ((count = libusb_get_device_list(usbContext, &usbDeviceList)) < 0) {
usbSetErrno(count, "libusb_get_device_list");
return NULL;
}
usbDeviceCount = count;
}
if ((devx = malloc(sizeof(*devx)))) {
libusb_device **libusbDevice = usbDeviceList;
int deviceCount = usbDeviceCount;
while (deviceCount) {
deviceCount -= 1;
devx->device = *libusbDevice++;
libusb_ref_device(devx->device);
devx->handle = NULL;
{
UsbDevice *device = usbTestDevice(devx, chooser, data);
if (device) return device;
}
libusb_unref_device(devx->device);
}
free(devx);
} else {
logMallocError();
}
return NULL;
}
static int
usbTestHostDevice (void *item, void *data) {
const UsbHostDevice *host = item;
UsbTestHostDeviceData *test = data;
UsbDeviceExtension *devx;
if ((devx = malloc(sizeof(*devx)))) {
memset(devx, 0, sizeof(*devx));
devx->host = host;
devx->usbfsFile = -1;
if ((test->device = usbTestDevice(devx, test->chooser, test->data))) return 1;
usbDeallocateDeviceExtension(devx);
} else {
logMallocError();
}
return 0;
}
UsbDevice *
usbFindDevice (UsbDeviceChooser *chooser, UsbChooseChannelData *data) {
UsbDevice *device = NULL;
static const char *const rootPath = "/dev/usb";
int rootLength = strlen(rootPath);
DIR *rootDirectory;
if ((rootDirectory = opendir(rootPath))) {
struct dirent *deviceEntry;
while ((deviceEntry = readdir(rootDirectory))) {
const char *deviceName = deviceEntry->d_name;
int deviceLength = strlen(deviceName);
{
unsigned int vendor;
unsigned int product;
int length;
if (sscanf(deviceName, "%x.%x%n", &vendor, &product, &length) < 2) continue;
if (length != deviceLength) continue;
}
deviceLength += rootLength + 1;
{
char devicePath[deviceLength + 1];
DIR *deviceDirectory;
sprintf(devicePath, "%s/%s", rootPath, deviceName);
if ((deviceDirectory = opendir(devicePath))) {
struct dirent *instanceEntry;
while ((instanceEntry = readdir(deviceDirectory))) {
const char *instanceName = instanceEntry->d_name;
int instanceLength = strlen(instanceName);
{
unsigned int number;
int length;
if (sscanf(instanceName, "%u%n", &number, &length) < 1) continue;
if (length != instanceLength) continue;
}
instanceLength += deviceLength + 1;
{
char instancePath[instanceLength + 1];
UsbDeviceExtension *devx;
sprintf(instancePath, "%s/%s", devicePath, instanceName);
if ((devx = malloc(sizeof(*devx)))) {
if ((devx->path = strdup(instancePath))) {
if (usbOpenEndpointFiles(devx->path, "cntrl0", &devx->data, &devx->status, O_RDWR)) {
if ((device = usbTestDevice(devx, chooser, data))) break;
close(devx->status);
close(devx->data);
}
free(devx->path);
}
free(devx);
}
}
}
closedir(deviceDirectory);
}
}
if (device) break;
}
closedir(rootDirectory);
}
return device;
}
UsbDevice *
usbFindDevice (UsbDeviceChooser *chooser, UsbChooseChannelData *data) {
UsbDevice *device = NULL;
int result;
{
static int initialized = 0;
if (!initialized) {
usb_init();
initialized = 1;
}
}
if ((result = usb_find_busses()) >= 0) {
if ((result = usb_find_devices()) >= 0) {
struct usb_bus *bus = usb_get_busses();
if (bus) {
struct usb_bus *bus0 = bus;
do {
struct usb_device *dev = bus->devices;
if (dev) {
struct usb_device *dev0 = dev;
do {
UsbDeviceExtension *devx;
if ((devx = malloc(sizeof(*devx)))) {
if ((devx->handle = usb_open(dev))) {
if ((device = usbTestDevice(devx, chooser, data))) return device;
usb_close(devx->handle);
} else {
logMessage(LOG_ERR, "USB open error: vendor=%X product=%X",
getLittleEndian16(dev->descriptor.idVendor),
getLittleEndian16(dev->descriptor.idProduct));
}
free(devx);
} else {
logSystemError("USB device extension allocate");
}
if ((dev = dev->next) == dev0) dev = NULL;
} while (dev);
}
if ((bus = bus->next) == bus0) bus = NULL;
} while (bus);
}
} else {
errno = -result;
logSystemError("USB devices find");
}
} else {
errno = -result;
logSystemError("USB busses find");
}
return device;
}
