void
_dump_dev_strings(libusb_device_handle *phDev,
struct libusb_device_descriptor *pdDev,
const char *pIndent)
{
unsigned char pStr[256];
int rc;
memset(pStr, 0, sizeof(pStr));
rc = libusb_get_string_descriptor_ascii(phDev, pdDev->iManufacturer,
pStr, sizeof(pStr));
TRACE(2, "%sMFG'r string (index %d, len = %d) = '%s'\n",
pIndent,
pdDev->iManufacturer, rc, pStr);
rc = libusb_get_string_descriptor_ascii(phDev, pdDev->iProduct,
pStr, sizeof(pStr));
TRACE(2, "%sProduct string (index %d, len = %d) = '%s'\n",
pIndent,
pdDev->iProduct, rc, pStr);
rc = libusb_get_string_descriptor_ascii(phDev, pdDev->iSerialNumber,
pStr, sizeof(pStr));
TRACE(2, "%sProduct serial number (index %d, len = %d) = '%s'\n",
pIndent,
pdDev->iSerialNumber, rc, pStr);
}
libusb_device_handle* open_device(int vid, char *vendor_name, int pid, char *product_name)
{
libusb_device **devices;
libusb_device *device;
libusb_device_handle *handle = NULL;
struct libusb_device_descriptor desc;
bool found = false;
unsigned char device_vendor_name[256], device_product_name[256];
int i = 0;
libusb_init(NULL);
libusb_get_device_list(NULL, &devices);
while((device = devices[i++]) != NULL) {
if(libusb_get_device_descriptor(device, &desc) < 0) {
fprintf(stderr, "Warning: Failed to get device descriptor");
continue;
}
if(desc.idVendor == vid && desc.idProduct == pid) {
if(libusb_open(device, &handle) < 0) {
fprintf(stderr, "Warning: cannot open usb device\n");
continue;
}
// Get Vendor name from device
if(libusb_get_string_descriptor_ascii(handle,
desc.iManufacturer,
device_vendor_name,
sizeof(device_vendor_name)) < 0 ) {
fprintf(stderr, "Warning: cannot get vendor name\n");
libusb_close(handle);
continue;
}
// Get Device name
if(libusb_get_string_descriptor_ascii(handle,
desc.iProduct,
device_product_name,
sizeof(device_product_name)) < 0) {
fprintf(stderr, "Warning: cannot get vendor name\n");
libusb_close(handle);
continue;
}
if( strcmp(vendor_name, (char*) device_vendor_name) == 0 &&
strcmp(product_name, (char*) device_product_name) == 0) {
found = true;
break;
}
else {
libusb_close(handle);
}
}
}
libusb_free_device_list(devices, 1);
if(found) {
return handle;
}
else {
return NULL;
}
}
int EnttecDMXDevice::open()
{
libusb_device_descriptor dd;
int r = libusb_get_device_descriptor(mDevice, &dd);
if (r < 0) {
return r;
}
r = libusb_open(mDevice, &mHandle);
if (r < 0) {
return r;
}
/*
* Match the manufacturer and product strings! This is the least intrusive way to
* determine that the attached device is in fact an Enttec DMX USB Pro, since it doesn't
* have a unique vendor/product ID.
*/
if (dd.iManufacturer && dd.iProduct && dd.iSerialNumber) {
char manufacturer[256];
char product[256];
r = libusb_get_string_descriptor_ascii(mHandle, dd.iManufacturer, (uint8_t*)manufacturer, sizeof manufacturer);
if (r < 0) {
return r;
}
r = libusb_get_string_descriptor_ascii(mHandle, dd.iProduct, (uint8_t*)product, sizeof product);
if (r < 0) {
return r;
}
mFoundEnttecStrings = !strcmp(manufacturer, "ENTTEC") && !strcmp(product, "DMX USB PRO");
}
/*
* Only go further if we have in fact found evidence that this is the right device.
*/
if (mFoundEnttecStrings) {
// Only relevant on linux; try to detach the FTDI driver.
libusb_detach_kernel_driver(mHandle, 0);
r = libusb_claim_interface(mHandle, 0);
if (r < 0) {
return r;
}
r = libusb_get_string_descriptor_ascii(mHandle, dd.iSerialNumber,
(uint8_t*)mSerialBuffer, sizeof mSerialBuffer);
if (r < 0) {
return r;
}
}
return 0;
}
std::vector<DeviceInfo> UsbHandler::get_device_list ()
{
libusb_device** devs;
int cnt = libusb_get_device_list(this->session->get_session(), &devs);
if (cnt < 0)
{
throw std::runtime_error("Unable to retrieve device list. " + std::to_string(cnt));
}
std::vector<DeviceInfo> ret;
ret.reserve(5);
for (ssize_t i = 0; i < cnt; i++)
{
libusb_device_descriptor desc;
int r = libusb_get_device_descriptor(devs[i], &desc);
if (r < 0)
{
throw std::runtime_error("Unable to retrieve device descriptor. " + std::to_string(cnt));
}
// ignore all devices that are not from TIS or otherwise needed
if (desc.idVendor != 0x199e)
continue;
if (desc.idProduct != 0x8209 && desc.idProduct != 0x0804)
continue;
tcam_device_info d = { };
d.type = TCAM_DEVICE_TYPE_LIBUSB;
libusb_device_handle* dh;
r = libusb_open(devs[i], &dh);
if (r < 0)
{
tcam_log(TCAM_LOG_ERROR, "Unable to open device.");
continue;
}
snprintf((char*)d.additional_identifier, sizeof(d.additional_identifier),
"%x", desc.idProduct);
libusb_get_string_descriptor_ascii(dh, desc.iProduct, (unsigned char*)d.name, sizeof(d.name));
libusb_get_string_descriptor_ascii(dh, desc.iSerialNumber, (unsigned char*)d.serial_number, sizeof(d.serial_number));
libusb_close(dh);
ret.push_back(DeviceInfo(d));
}
libusb_free_device_list(devs, 1);
return ret;
}
int list_usb_devices(int dbg)
{
int i, n, cams = 0;
struct uviface *uvi;
libusb_device **uds;
struct libusb_device_descriptor udd;
unsigned char buf[BUFSZ];
/* context, ***list */
if((n = libusb_get_device_list(ctx, &uds)) < 0)
{
perror("Could not retrive devcice list");
return n;
}
if(dbg) printf("N\tVendor:Prod\tBus:Addr\tIface\tManufacturer\n"
"\t\t\t\t\t\tProduct\n\t\t\t\t\t\tSN\n\n");
for(i = 0; i < n; i++)
{
if((uvi = open_uvi_index(i)) == NULL) continue;
else cams++;
if(libusb_get_device_descriptor(uds[i], &udd) != 0)
{
perror("Could not get device descriptor");
close_uvi(uvi);
continue;
}
printf("%d\t%04x:%04x\t%02d:%02d\t\t%d\t", i,
udd.idVendor, udd.idProduct,
libusb_get_bus_number(uds[i]),
libusb_get_device_address(uds[i]),
uvi->iface);
/* args: handle, desc_index, buf, sizeof(buf) */
if(libusb_get_string_descriptor_ascii(uvi->udh,
udd.iManufacturer, buf, BUFSZ) < 1)
strcpy((char *)&buf, DESC_ERR);
printf("%s\n", buf);
if(libusb_get_string_descriptor_ascii(uvi->udh,
udd.iProduct, buf, BUFSZ) < 1)
strcpy((char *)&buf, DESC_ERR);
printf("\t\t\t\t\t\t%s\n", buf);
if(libusb_get_string_descriptor_ascii(uvi->udh,
udd.iSerialNumber, buf, BUFSZ) < 1)
strcpy((char *)&buf, DESC_ERR);
printf("\t\t\t\t\t\t%s\n\n", buf);
close_uvi(uvi);
}
/* **list, unref devices with int */
libusb_free_device_list(uds, 1);
if(dbg) printf("summary: %d devices found, %d are video devices.\n",
n, cams);
return 0;
}
static void smartreader_check_endpoint(libusb_device *usb_dev, libusb_device_handle *handle)
{
struct libusb_device_descriptor usbdesc;
struct libusb_config_descriptor *configDesc;
int32_t ret;
int32_t j,k,l;
uint32_t m;
uint8_t tmpEndpointAddress;
int32_t nb_endpoint_ok;
int32_t busid, devid;
unsigned char iserialbuffer[128], iproductbuffer[128];
char *productptr = (char *)iproductbuffer;
nb_endpoint_ok=0;
ret = libusb_get_device_descriptor(usb_dev, &usbdesc);
if (ret < 0) {
printf("Smartreader : couldn't read device descriptor, assuming this is not a smartreader");
return;
}
if (usbdesc.bNumConfigurations) {
ret=libusb_get_active_config_descriptor(usb_dev,&configDesc);
if(ret) {
printf("Smartreader : couldn't read config descriptor , assuming this is not a smartreader");
return;
}
for(m = 0; m < sizeof(reader_types)/sizeof(struct s_reader_types); ++m){
nb_endpoint_ok = 0;
for(j=0; j<configDesc->bNumInterfaces; j++) {
for(k=0; k<configDesc->interface[j].num_altsetting; k++) {
for(l=0; l<configDesc->interface[j].altsetting[k].bNumEndpoints; l++) {
tmpEndpointAddress=configDesc->interface[j].altsetting[k].endpoint[l].bEndpointAddress;
if((tmpEndpointAddress == reader_types[m].in_ep || tmpEndpointAddress == reader_types[m].out_ep)){
nb_endpoint_ok++;
}
}
}
}
if(nb_endpoint_ok == 2){
busid=libusb_get_bus_number(usb_dev);
devid=libusb_get_device_address(usb_dev);
memset(iserialbuffer, 0, sizeof(iserialbuffer));
memset(iproductbuffer, 0, sizeof(iproductbuffer));
libusb_get_string_descriptor_ascii(handle,usbdesc.iSerialNumber,iserialbuffer,sizeof(iserialbuffer));
libusb_get_string_descriptor_ascii(handle,usbdesc.iProduct,iproductbuffer,sizeof(iproductbuffer));
printf("bus %03d, device %03d : %04x:%04x %s (type=%s, in_ep=%02x, out_ep=%02x; insert in oscam.server 'device = %s%sSerial:%s')\n",
busid, devid,
usbdesc.idVendor, usbdesc.idProduct, strlen(productptr)>0?productptr:"Smartreader",
reader_types[m].name, reader_types[m].in_ep, reader_types[m].out_ep,
strcmp(reader_types[m].name, "SR")?reader_types[m].name:"",strcmp(reader_types[m].name, "SR")?";":"", iserialbuffer
);
}
}
}
}
int main(int ac, char **av) {
libusb_context *context;
libusb_device **devices;
struct libusb_device_descriptor device_desc;
int status;
int i;
unsigned char manufacturer[128];
unsigned char product[128];
int length;
libusb_device_handle *handle;
status = libusb_init(&context);
if (status) {
printf ("libusb_init: failed with code=%s\n", libusb_error_name(status));
return 0;
}
int nDevices = libusb_get_device_list(context, &devices);
if (status < 0) {
printf ("libusb_get_device_list: failed with code=%d\n", status);
} else {
for (i = 0; i < nDevices; i++) {
libusb_device *device = devices[i];
status = libusb_get_device_descriptor(device, &device_desc);
if (status) {
printf ("libusb_get_device_descriptor: failed with code=%s\n", libusb_error_name(status));
} else {
printf ("VID=%04X/PID=%04X ", device_desc.idVendor, device_desc.idProduct);
status = libusb_open(device, &handle);
if (status < 0) {
printf ("libusb_open: failed with code=%s\n", libusb_error_name(status));
} else {
length = libusb_get_string_descriptor_ascii(handle, device_desc.iManufacturer, manufacturer, sizeof manufacturer - 2);
if (length < 0) {
printf ("libusb_get_string_descriptor_ascii: failed with code=%s\n", libusb_error_name(length));
} else {
manufacturer[length] = 0;
printf ("%s ", manufacturer);
}
length = libusb_get_string_descriptor_ascii(handle, device_desc.iProduct, product, sizeof product - 2);
if (length < 0) {
printf ("libusb_get_string_descriptor_ascii: failed with code=%s\n", libusb_error_name(length));
} else {
product[length] = 0;
printf ("%s ", product);
}
libusb_close(handle);
}
printf ("\n");
}
}
libusb_free_device_list(devices, 1);
}
libusb_exit(context);
return (0);
}
std::vector<device_info> UsbHandler::get_device_list ()
{
libusb_device** devs;
int cnt = libusb_get_device_list(this->session->get_session(), &devs);
if (cnt < 0)
{
throw std::runtime_error("Unable to retrieve device list. " + std::to_string(cnt));
}
std::vector<device_info> ret;
ret.reserve(20);
for (ssize_t i = 0; i < cnt; i++)
{
libusb_device_descriptor desc;
int r = libusb_get_device_descriptor(devs[i], &desc);
if (r < 0)
{
throw std::runtime_error("Unable to retrieve device descriptor. " + std::to_string(cnt));
}
// ignore all devices that are not from TIS or otherwise needed
if (desc.idVendor != 0x199e && desc.idVendor != 0xeb1a && desc.idVendor != 0x04b4)
continue;
device_info d = { 0 };
d.idVendor = desc.idVendor;
d.idProduct = desc.idProduct;
libusb_device_handle* dh;
r = libusb_open(devs[i], &dh);
if (r < 0)
{
throw std::runtime_error("Unable to open device.");
}
// TODO find alternative to root requirements
libusb_get_string_descriptor_ascii(dh, desc.iProduct, (unsigned char*)d.product, sizeof(d.product));
libusb_get_string_descriptor_ascii(dh, desc.iSerialNumber, (unsigned char*)d.serial, sizeof(d.serial));
libusb_close(dh);
ret.push_back(d);
}
libusb_free_device_list(devs, 1);
return ret;
}
void vrpn_libusb::printDevices(libusb_device ** list)
{
libusb_device * dev;
int i = 0;
while((dev = list[i++]) != NULL)
{
libusb_device_descriptor desc;
if(libusb_get_device_descriptor(dev, &desc) < 0)
{
std::cerr << "Error getting device descriptor for usb device " << i-1 << std::endl;
continue;
}
libusb_device_handle * handle;
if(libusb_open(dev, &handle) < 0)
{
std::cerr << "Error opening device " << i-1 << std::endl;
continue;
}
unsigned char buffer[255];
std::cerr << "Device: " << i-1 << std::endl;
if(desc.iManufacturer)
{
libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, buffer, 255);
std::cerr << "Manufacturer: " << buffer << std::endl;
}
if(desc.iProduct)
{
libusb_get_string_descriptor_ascii(handle, desc.iProduct, buffer, 255);
std::cerr << "Product: " << buffer << std::endl;
}
if(desc.iSerialNumber)
{
libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, buffer, 255);
std::cerr << "Serial Number: " << buffer << std::endl;
}
std::cerr << "VendorID: " << desc.idVendor << std::endl;
std::cerr << "ProductID: " << desc.idProduct << std::endl;
std::cerr << std::endl;
libusb_close(handle);
}
}
int usb_get_device_name(libusb_device_handle *device_handle, char *name, int length) {
int rc;
libusb_device *device = libusb_get_device(device_handle);
uint8_t bus_number = libusb_get_bus_number(device);
uint8_t device_address = libusb_get_device_address(device);
struct libusb_device_descriptor descriptor;
char product[64];
char serial_number[64];
// get device descriptor
rc = libusb_get_device_descriptor(device, &descriptor);
if (rc < 0) {
log_error("Could not get device descriptor for USB device (bus: %u, device: %u): %s (%d)",
bus_number, device_address, usb_get_error_name(rc), rc);
return -1;
}
// get product string descriptor
rc = libusb_get_string_descriptor_ascii(device_handle,
descriptor.iProduct,
(unsigned char *)product,
sizeof(product));
if (rc < 0) {
log_error("Could not get product string descriptor for USB device (bus: %u, device: %u): %s (%d)",
bus_number, device_address, usb_get_error_name(rc), rc);
return -1;
}
// get serial number string descriptor
rc = libusb_get_string_descriptor_ascii(device_handle,
descriptor.iSerialNumber,
(unsigned char *)serial_number,
sizeof(serial_number));
if (rc < 0) {
log_error("Could not get serial number string descriptor for USB device (bus: %u, device: %u): %s (%d)",
bus_number, device_address, usb_get_error_name(rc), rc);
return -1;
}
// format name
snprintf(name, length, "%s [%s]", product, serial_number);
return 0;
}
static void tigl_get_product(char * string, size_t maxlen, struct libusb_device *dev)
{
libusb_device_handle *han;
int ret;
struct libusb_device_descriptor desc;
int r = libusb_get_device_descriptor(dev, &desc);
string[0] = 0;
if (r < 0)
{
ticables_critical("failed to get device descriptor");
}
if (desc.iProduct)
{
if (!libusb_open(dev, &han))
{
ret = libusb_get_string_descriptor_ascii(han, desc.iProduct, (unsigned char *) string, maxlen);
libusb_close(han);
if (ret <= 0)
{
ticables_warning("libusb_get_string_descriptor_ascii (%s).\n", tigl_strerror(ret));
}
}
// else do nothing.
}
}
void IntersonManagerTest::printDevices(libusb_device ** deviceList)
{
libusb_device *dev;
int i = 0, j = 0;
uint8_t path[8];
uint8_t string_index[3]; // indexes of the string descriptors
char string[128];
while ((dev = deviceList[i]) != NULL)
{
printf("\n");
struct libusb_device_descriptor desc;
int r = libusb_get_device_descriptor(dev, &desc);
if (r < 0)
{
fprintf(stderr, "failed to get device descriptor");
return;
}
string_index[0] = desc.iManufacturer;
string_index[1] = desc.iProduct;
string_index[2] = desc.iSerialNumber;
printf("%04x:%04x (bus %d, device %d)",
desc.idVendor, desc.idProduct,
libusb_get_bus_number(dev), libusb_get_device_address(dev));
r = libusb_get_port_numbers(dev, path, sizeof(path));
if (r > 0) {
printf(" path: %d", path[0]);
for (j = 1; j < r; j++)
printf(".%d", path[j]);
}
printf("\n");
libusb_device_handle *handle;
r = libusb_open(dev, &handle);
if(r == LIBUSB_ERROR_ACCESS)
{
std::cout<<" Insufficient permission"<<std::endl;
}
if (r == 0 && handle != NULL)
{
for (int k = 0; k < 3; k++)
{
if (string_index[k] == 0)
{
continue;
}
if (libusb_get_string_descriptor_ascii(handle, string_index[k], (unsigned char *) string, 128) >= 0)
{
printf("String Desc(0x%02X): \"%s\"\n", string_index[k], string);
}
}
libusb_close(handle);
}
i++;
}
}
int CNIF_USB_CmpSerialNum(const char *serial)
{
int ret = 0;
int length = 0;
char tmp_serial[CN_DEVICE_ID_LEN];
struct libusb_device_descriptor devdesc;
ret = libusb_get_device_descriptor(g_device, &devdesc);
if(ret < 0) {
#ifdef _DEBUG_MODE_
fprintf(stderr, "ERROR: get device descriptor was failed\n");
#endif
return CN_USB_WRITE_ERROR;
}
length = libusb_get_string_descriptor_ascii(g_dh, devdesc.iSerialNumber,
(unsigned char *)tmp_serial,
sizeof(tmp_serial) - 1);
if(length > 0) {
tmp_serial[length] = '\0';
}
#ifdef _DEBUG_MODE_
fprintf(stderr, "DEBUG: get_serialNum = %s, know serialnum = %s\n", tmp_serial, serial);
#endif
if(strncmp(tmp_serial, serial, length)){
return CN_USB_WRITE_ERROR;
}
#ifdef _DEBUG_MODE_
fprintf(stderr, "DEBUG: the same serial number\n");
#endif
return 0;
}
/* Retrieves alternate interface name string.
* Returns string length, or negative on error */
int get_alt_name(struct dfu_if *dfu_if, unsigned char *name)
{
libusb_device *dev = dfu_if->dev;
struct libusb_config_descriptor *cfg;
int alt_name_str_idx;
int ret;
ret = libusb_get_config_descriptor_by_value(dev, dfu_if->configuration,
&cfg);
if (ret)
return ret;
alt_name_str_idx = cfg->interface[dfu_if->interface].
altsetting[dfu_if->altsetting].iInterface;
ret = -1;
if (alt_name_str_idx) {
if (!dfu_if->dev_handle)
if (libusb_open(dfu_if->dev, &dfu_if->dev_handle))
dfu_if->dev_handle = NULL;
if (dfu_if->dev_handle)
ret = libusb_get_string_descriptor_ascii(
dfu_if->dev_handle, alt_name_str_idx,
name, MAX_DESC_STR_LEN);
}
libusb_free_config_descriptor(cfg);
return ret;
}
int irecv_get_string_descriptor_ascii(irecv_client_t client, uint8_t desc_index, unsigned char * buffer, int size) {
#ifndef WIN32
return libusb_get_string_descriptor_ascii(client->handle, desc_index, buffer, size);
#else
irecv_error_t ret;
unsigned short langid = 0;
unsigned char data[255];
int di, si;
memset(data, 0, sizeof(data));
memset(buffer, 0, size);
ret = irecv_control_transfer(client, 0x80, 0x06, (0x03 << 8) | desc_index, langid, data, sizeof(data), 1000);
if (ret < 0) return ret;
if (data[1] != 0x03) return IRECV_E_UNKNOWN_ERROR;
if (data[0] > ret) return IRECV_E_UNKNOWN_ERROR;
for (di = 0, si = 2; si < data[0]; si += 2) {
if (di >= (size - 1)) break;
if (data[si + 1]) {
/* high byte */
buffer[di++] = '?';
} else {
buffer[di++] = data[si];
}
}
buffer[di] = 0;
return di;
#endif
}
static int is_our_device(libusb_device *dev,
struct libusb_device_descriptor desc)
{
static const int SERIAL_MAX = 1024;
unsigned char serial[1024];
if ((g_options.vendor_id && desc.idVendor != g_options.vendor_id) &&
(g_options.product_id && desc.idProduct != g_options.product_id))
return 0;
if (g_options.serial_num == NULL)
return 1;
libusb_device_handle *handle = NULL;
int status = libusb_open(dev, &handle);
if (status != 0)
return 0;
status = libusb_get_string_descriptor_ascii(handle,
desc.iSerialNumber, serial, SERIAL_MAX);
libusb_close(handle);
if (status <= 0) {
WARN("Failed to get serial from device");
return 0;
}
return strcmp((char *)serial, (char *)g_options.serial_num) == 0;
}
void listUsbDeviceMatches(const unsigned short vid, const unsigned short pid)
{
libusb_device **devices;
ssize_t numDevices = libusb_get_device_list(NULL, &devices);
ssize_t i = 0;
for (i = 0; i < numDevices; i++) {
struct libusb_device_descriptor descriptor;
if (0 == libusb_get_device_descriptor(devices[i], &descriptor)) {
if (vid == descriptor.idVendor && pid == descriptor.idProduct) {
libusb_device_handle *handle;
if (0 == libusb_open(devices[i], &handle)) {
char usbSerial[64];
if (0 == descriptor.iSerialNumber ||
0 == libusb_get_string_descriptor_ascii(handle, descriptor.iSerialNumber, (unsigned char *)usbSerial, sizeof(usbSerial)))
usbSerial[0] = '\0';
fprintf(stderr, "USB device pid/vid match: vid=0x%04x pid=0x%04x serial='%s'\n", descriptor.idVendor, descriptor.idProduct, usbSerial);
libusb_close(handle);
}
}
}
}
libusb_free_device_list(devices, 1);
}
/* Returns true if the string descriptor indexed by str_index in device matches string */
static bool string_descriptor_equal(libusb_device_handle *device, uint8_t str_index,
const char *string)
{
int retval;
bool matched;
const int DESC_SIZE = 256;
char desc_string[DESC_SIZE+1]; /* Max size of string descriptor */
if (str_index == 0)
return false;
retval = libusb_get_string_descriptor_ascii(device, str_index,
(unsigned char *)desc_string, sizeof(desc_string)-1);
if (retval < 0) {
LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval);
return false;
}
/* Null terminate descriptor string in case it needs to be logged. */
desc_string[sizeof(desc_string)-1] = '\0';
matched = strncmp(string, desc_string, sizeof(desc_string)) == 0;
if (!matched){
char desc_hex[DESC_SIZE*2+1];
string_to_hexstring(desc_hex,desc_string);
char req_hex[DESC_SIZE*2+1];
string_to_hexstring(req_hex,string);
LOG_DEBUG("Device serial number '%s' (0x%s) doesn't match requested serial '%s' (0x%s)",
desc_string, desc_hex, string, req_hex);
}
return matched;
}
// getserial - get the serialnumber of the device
//
// Inputs:
// num = device to get serial from
// Output
// QString conatining device serial or empty QString
//
QString pjrc_rawhid::getserial(int num)
{
if ((std::size_t)num >= m_DeviceHandles.size()) {
fprintf(stderr, "pjrc_rawhid_unix: Invalid device number used (%d)\n", num);
return "";
}
if (m_DeviceHandles[num] == NULL) {
fprintf(stderr, "pjrc_rawhid_unix: Tried to use a device which is not open (%d)\n", num);
return "";
}
struct libusb_device_descriptor desc;
struct libusb_device * dev = libusb_get_device(m_DeviceHandles[num]);
int retval;
retval = libusb_get_device_descriptor(dev, &desc);
if (retval < 0) {
fprintf(stderr, "pjrc_rawhid_unix: Failed to get device descriptor (%d)\n", retval);
return "";
}
unsigned char buf[128];
retval = libusb_get_string_descriptor_ascii(m_DeviceHandles[num], desc.iSerialNumber, buf, sizeof(buf));
if (retval < 0) {
fprintf(stderr, "pjrc_rawhid_unix: Coudn't get serial string (%d)\n", retval);
return "";
}
return QString().fromUtf8((char*)buf,-1);
}
static libusb_device_handle *find_device(const unsigned short vid, const unsigned short pid, const char *serial)
{
libusb_device_handle *handle = NULL;
libusb_device **devices;
ssize_t numDevices = libusb_get_device_list(NULL, &devices);
ssize_t i = 0;
for (i = 0; i < numDevices; i++) {
struct libusb_device_descriptor descriptor;
if (0 == libusb_get_device_descriptor(devices[i], &descriptor)) {
if (vid == descriptor.idVendor && pid == descriptor.idProduct) {
if (0 == libusb_open(devices[i], &handle)) {
char usbSerial[64];
if (0 == descriptor.iSerialNumber ||
0 == libusb_get_string_descriptor_ascii(handle, descriptor.iSerialNumber, (unsigned char *)usbSerial, sizeof(usbSerial)))
usbSerial[0] = '\0';
if (matchesSerial(serial, usbSerial)) {
fprintf(stderr, "Connected to USB device with serial='%s'\n", usbSerial);
break;
}
else {
libusb_close(handle);
handle = NULL;
}
}
}
}
}
if (NULL == handle)
fprintf(stderr, "Warning: Could not find USB device with vid=0x%x pid=0x%x serial='%s'\n", vid, pid, serial);
libusb_free_device_list(devices, 1);
return handle;
}
int
usb_setup(char *name, size_t namelen)
{
if (libusb_init(NULL) < 0) {
return -1;
}
if (libusb_pollfds_handle_timeouts(NULL) == 0) {
printf("I'm too dumb to handle events on such an old system.\n");
return -1;
}
for (d = devices; d->product_id; d += 1) {
usb_dev = libusb_open_device_with_vid_pid(NULL, 0x6f8, d->product_id);
if (usb_dev) {
break;
}
}
if (! usb_dev) {
printf("Couldn't find a controller.\n");
return -1;
}
// Figure out what it's called
{
int ret;
struct libusb_device_descriptor ddesc;
libusb_get_device_descriptor(libusb_get_device(usb_dev), &ddesc);
ret = libusb_get_string_descriptor_ascii(usb_dev, ddesc.iManufacturer, (unsigned char *)name, namelen);
if (ret > 0) {
char *p = name + ret;
*p = ' ';
p += 1;
ret = libusb_get_string_descriptor_ascii(usb_dev, ddesc.iProduct, (unsigned char *)p, namelen - ret - 1);
}
if (ret < 0) {
printf("Warning: I can't figure out what to call this thing.\n");
}
printf("Opened [%s]\n", name);
}
usb_initiate_transfer();
return 0;
}
int fnusb_list_device_attributes(fnusb_ctx *ctx, struct freenect_device_attributes** attribute_list)
{
*attribute_list = NULL; // initialize some return value in case the user is careless.
libusb_device **devs;
//pointer to pointer of device, used to retrieve a list of devices
ssize_t count = libusb_get_device_list (ctx->ctx, &devs);
if (count < 0)
return -1;
struct freenect_device_attributes** camera_prev_next = attribute_list;
// Pass over the list. For each camera seen, if we already have a camera
// for the newest_camera device, allocate a new one and append it to the list,
// incrementing num_devs. Likewise for each audio device.
struct libusb_device_descriptor desc;
int num_cams = 0;
int i;
for (i = 0; i < count; i++) {
int r = libusb_get_device_descriptor (devs[i], &desc);
if (r < 0)
continue;
if (desc.idVendor == VID_MICROSOFT && desc.idProduct == PID_NUI_CAMERA) {
// Verify that a serial number exists to query. If not, don't touch the device.
if (desc.iSerialNumber == 0) {
continue;
}
// Open device.
int res;
libusb_device_handle *this_device;
res = libusb_open(devs[i], &this_device);
unsigned char string_desc[256]; // String descriptors are at most 256 bytes.
if (res != 0) {
continue;
}
// Read string descriptor referring to serial number.
res = libusb_get_string_descriptor_ascii(this_device, desc.iSerialNumber, string_desc, 256);
libusb_close(this_device);
if (res < 0) {
continue;
}
// Add item to linked list.
struct freenect_device_attributes* new_dev_attrs = (struct freenect_device_attributes*)malloc(sizeof(struct freenect_device_attributes));
memset(new_dev_attrs, 0, sizeof(*new_dev_attrs));
*camera_prev_next = new_dev_attrs;
// Copy string with serial number
new_dev_attrs->camera_serial = strdup((char*)string_desc);
camera_prev_next = &(new_dev_attrs->next);
// Increment number of cameras found
num_cams++;
}
}
libusb_free_device_list(devs, 1);
return num_cams;
}
static libusb_device_handle* canusb_opendevice(struct libusb_context *ctx, char* devserial)
{
libusb_device** devs;
unsigned char serial[65];
int cnt,i,n;
cnt = libusb_get_device_list(ctx,&devs);
for(i=0;i<cnt;i++)
{
/* Check if this device is interesting. */
struct libusb_device_descriptor desc;
libusb_device_handle *dh;
libusb_get_device_descriptor(devs[i],&desc);
if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
continue;
/* Found one! */
dh = NULL;
if (libusb_open(devs[i],&dh) != 0) continue;
n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,serial,64);
serial[n] = 0;
if ((devserial) && (strcmp((char *)serial,devserial) != 0))
{
libusb_close(dh);
continue;
}
if ((libusb_kernel_driver_active(dh,0)) && (libusb_detach_kernel_driver(dh,0) != 0))
{
libusb_close(dh);
continue;
}
if (libusb_set_configuration(dh,1) != 0)
{
libusb_close(dh);
continue;
}
if (libusb_claim_interface(dh,0) != 0)
{
libusb_close(dh);
continue;
}
/* Fount it! */
libusb_free_device_list(devs,1);
return dh;
}
libusb_free_device_list(devs,1);
return NULL;
}
static int matelight_cmp_str_desc(libusb_device_handle *dev, uint8_t index, char *value){
char data[256];
if(libusb_get_string_descriptor_ascii(dev, index, (unsigned char*)data, sizeof(data)) < 0){
fprintf(stderr, "LIBML: Cannot read device string descriptor\n");
return 0;
}
return strcmp(data, value) == 0;
}
static int
get_string_descriptor(libusb_device_handle* handle, int index,
char* string, int length)
{
return libusb_get_string_descriptor_ascii(handle, (index)&0xff,
(unsigned char*)string,
length);
}
int usbasp_uart_open(USBasp_UART* usbasp){
int errorCode = USB_ERROR_NOTFOUND;
libusb_context* ctx;
libusb_init(&ctx);
libusb_device** dev_list;
int dev_list_len = libusb_get_device_list(ctx, &dev_list);
for (int j=0; j<dev_list_len; ++j) {
libusb_device* dev = dev_list[j];
struct libusb_device_descriptor descriptor;
libusb_get_device_descriptor(dev, &descriptor);
if (descriptor.idVendor == USBASP_SHARED_VID
&& descriptor.idProduct == USBASP_SHARED_PID) {
uint8_t str[256];
libusb_open(dev, &usbasp->usbhandle);
if (!usbasp->usbhandle) {
errorCode = USB_ERROR_ACCESS;
continue;
}
libusb_get_string_descriptor_ascii(usbasp->usbhandle,
descriptor.iManufacturer & 0xff, str, sizeof(str));
if(strcmp("www.fischl.de", (const char*)str)){
libusb_close(usbasp->usbhandle);
usbasp->usbhandle=NULL;
continue;
}
dprintf("Vendor: %s\n", str);
libusb_get_string_descriptor_ascii(usbasp->usbhandle,
descriptor.iProduct & 0xff, str, sizeof(str));
if(strcmp("USBasp", (const char*)str)){
libusb_close(usbasp->usbhandle);
usbasp->usbhandle=NULL;
continue;
}
dprintf("Product: %s\n", str);
break;
}
}
libusb_free_device_list(dev_list,1);
if (usbasp->usbhandle != NULL){
errorCode = 0;
}
return errorCode;
}
matelight_handle *matelight_open(char *match_serial){
matelight_handle *out = NULL;
libusb_device_handle *handle = NULL;
libusb_device** device_list;
struct libusb_device_descriptor desc;
ssize_t res = libusb_get_device_list(NULL, &device_list);
if(res == 0){
fprintf(stderr, "LIBML: Cannot find any connected matelight\n");
goto error;
}else if(res < 0){
fprintf(stderr, "LIBML: Error enumerating connected USB devices\n");
goto error;
}else{
out = calloc(1, sizeof(matelight_handle));
if(!out){
fprintf(stderr, "LIBML: Cannot allocate memory\n");
goto error;
}
for(ssize_t i=0; i<res; i++){
libusb_get_device_descriptor(device_list[i], &desc);
if(desc.idVendor == MATELIGHT_VID && desc.idProduct == MATELIGHT_PID){
if(libusb_open(device_list[i], &handle)){
fprintf(stderr, "LIBML: Cannot open Mate Light USB device\n");
goto error;
}
out->handle = handle;
if(matelight_cmp_str_desc(handle, desc.iManufacturer, "Gold & Apple"))
if(matelight_cmp_str_desc(handle, desc.iProduct, "Mate Light"))
if(!match_serial || matelight_cmp_str_desc(handle, desc.iSerialNumber, match_serial)){
#define BUF_SIZE 256
out->serial = malloc(BUF_SIZE);
if(!out->serial){ fprintf(stderr, "LIBML: Cannot allocate memory\n");
goto error;
}
if(libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, (unsigned char*)&out->serial, BUF_SIZE) < 0){
fprintf(stderr, "LIBML: Cannot read device string descriptor\n");
goto error;
}
#undef BUF_SIZE
return out;
}
}
}
}
libusb_free_device_list(device_list, 1);
return NULL;
error:
if(out){
if(out->serial)
free(out->serial);
free(out);
}
if(handle)
libusb_close(handle);
libusb_free_device_list(device_list, 1);
return NULL;
}
int canusb_findalldevs(pcap_if_t **alldevsp, char *err_str)
{
libusb_context *fdctx;
libusb_device** devs;
unsigned char sernum[65];
int cnt, i;
if (libusb_init(&fdctx) != 0) {
/*
* XXX - if this doesn't just mean "no USB file system mounted",
* perhaps we should report a real error rather than just
* saying "no CANUSB devices".
*/
return 0;
}
cnt = libusb_get_device_list(fdctx,&devs);
for(i=0;i<cnt;i++)
{
int ret;
/* Check if this device is interesting. */
struct libusb_device_descriptor desc;
libusb_device_handle *dh;
libusb_get_device_descriptor(devs[i],&desc);
if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
continue; /* It is not, check next device */
/* It is! */
dh = NULL;
if ((ret = libusb_open(devs[i],&dh)) == 0)
{
char dev_name[30];
char dev_descr[50];
int n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,sernum,64);
sernum[n] = 0;
pcap_snprintf(dev_name, 30, CANUSB_IFACE"%s", sernum);
pcap_snprintf(dev_descr, 50, "CanUSB [%s]", sernum);
libusb_close(dh);
if (pcap_add_if(alldevsp, dev_name, 0, dev_descr, err_str) < 0)
{
libusb_free_device_list(devs,1);
libusb_exit(fdctx);
return -1;
}
}
}
libusb_free_device_list(devs,1);
libusb_exit(fdctx);
return 0;
}
static QString get_string(libusb_device_handle *handle, u_int8_t id) {
unsigned char buf[128] = { 0 };
if (id) {
libusb_get_string_descriptor_ascii(handle, id, buf, sizeof(buf));
}
return QString::fromAscii((char*)buf);
}
int ncusb_match_string(libusb_device_handle *dev, int index, const char* string)
{
unsigned char tmp[256];
libusb_get_string_descriptor_ascii(dev, index, tmp, 256);
slog(4, SLOG_DEBUG, "cmp idx %d str %s vs %s", index, tmp, string);
if (string == NULL)
return 1; /* NULL matches anything */
return (strcmp(string, (char*) tmp)==0);
}
