static t_int get_device_string(HIDInterface *hidif, char *device_string)
{
int length;
t_int ret = 0;
char buffer[STRING_BUFFER_LENGTH] = "";
char return_buffer[STRING_BUFFER_LENGTH] = "";
if ( !hid_is_opened(hidif) )
return(0);
if (hidif->device->descriptor.iManufacturer) {
length = usb_get_string_simple(hidif->dev_handle,
hidif->device->descriptor.iManufacturer,
buffer,
STRING_BUFFER_LENGTH);
if (length > 0)
{
strncat(return_buffer, buffer, STRING_BUFFER_LENGTH - strlen(device_string));
strncat(return_buffer, " ",1);
ret = 1;
}
else
{
post("(unable to fetch manufacturer string)");
}
}
if (hidif->device->descriptor.iProduct) {
length = usb_get_string_simple(hidif->dev_handle,
hidif->device->descriptor.iProduct,
buffer,
STRING_BUFFER_LENGTH);
if (length > 0)
{
strncat(return_buffer, buffer, STRING_BUFFER_LENGTH - strlen(device_string));
strncat(return_buffer, " ",1);
ret = 1;
}
else
{
post("(unable to fetch product string)");
}
}
if (hidif->device->descriptor.iSerialNumber) {
length = usb_get_string_simple(hidif->dev_handle,
hidif->device->descriptor.iSerialNumber,
buffer,
STRING_BUFFER_LENGTH);
if (length > 0)
strncat(return_buffer, buffer, STRING_BUFFER_LENGTH - strlen(device_string));
else
post("(unable to fetch product string)");
}
if (return_buffer)
strncpy(device_string, return_buffer, STRING_BUFFER_LENGTH);
return ret;
}
/**
* Retrieve descriptions of scanned devices. Retrived desctiptions are stored internally.
* @return positive number of retrieved devices.<br>-1 on failure
* @sa get_serial_id(unsigned int, std::string&), get_serial_id(std::string&)
* , get_manufacturer(unsigned int, std::string&), get_manufacturer(std::string&)
* , get_product(unsigned int, std::string&), get_product(std::string&)
**/
int retrieve()
{
if( !scanned ) if ( scan() < 0 ) return -1;
if( devices.empty() ) return -1;
char buff[128];
descriptions.clear();
for (unsigned int i=0; i<devices.size(); i++) {
struct usb_device *dev = devices[i];
usb_dev_handle *h = usb_open(dev);
if ( h < 0 ) continue;
std::map<std::string, std::string> M_desc;
if ( usb_get_string_simple(h, dev->descriptor.iSerialNumber, buff, 128) < 0 ) continue;
M_desc["serial_number"] = std::string(buff);
if ( usb_get_string_simple(h, dev->descriptor.iManufacturer, buff, 128) < 0 ) continue;
M_desc["manufacturer"] = std::string(buff);
if ( usb_get_string_simple(h, dev->descriptor.iProduct, buff, 128) < 0 ) continue;
M_desc["product"] = std::string(buff);
descriptions.push_back(M_desc);
}
retrieved = true;
return descriptions.size();
}
static bool
acr122_usb_get_usb_device_name(struct usb_device *dev, usb_dev_handle *udev, char *buffer, size_t len)
{
*buffer = '\0';
if (dev->descriptor.iManufacturer || dev->descriptor.iProduct) {
if (udev) {
usb_get_string_simple(udev, dev->descriptor.iManufacturer, buffer, len);
if (strlen(buffer) > 0)
strcpy(buffer + strlen(buffer), " / ");
usb_get_string_simple(udev, dev->descriptor.iProduct, buffer + strlen(buffer), len - strlen(buffer));
}
}
if (!*buffer) {
for (size_t n = 0; n < sizeof(acr122_usb_supported_devices) / sizeof(struct acr122_usb_supported_device); n++) {
if ((acr122_usb_supported_devices[n].vendor_id == dev->descriptor.idVendor) &&
(acr122_usb_supported_devices[n].product_id == dev->descriptor.idProduct)) {
strncpy(buffer, acr122_usb_supported_devices[n].name, len);
buffer[len - 1] = '\0';
return true;
}
}
}
return false;
}
hid_return hid_write_identification(FILE* const out,
HIDInterface const* const hidif)
{
if (!hid_is_opened(hidif)) {
ERROR("cannot write identification of unopened HIDinterface.");
return HID_RET_DEVICE_NOT_OPENED;
}
if (!out) {
ERROR("cannot write HIDinterface identification of USB device %s "
"to NULL output stream.", hidif->id);
return HID_RET_INVALID_PARAMETER;
}
int len;
unsigned short const BUFLEN = 256;
char buffer[BUFLEN];
fprintf(out, "device identification of HIDInterface %s:\n", hidif->id);
fprintf(out, " dev_handle: 0x%08lx\n", (unsigned long)hidif->dev_handle);
fprintf(out, " device: 0x%08lx\n", (unsigned long)hidif->device);
fprintf(out, " location: %s/%s\n",
hidif->device->bus->dirname, hidif->device->filename);
if (hidif->device->descriptor.iManufacturer) {
len = usb_get_string_simple(hidif->dev_handle,
hidif->device->descriptor.iManufacturer, buffer, BUFLEN);
if (len > 0)
fprintf(out, " manufacturer: %s\n", buffer);
else
fprintf(out, "(unable to fetch manufacturer string)\n");
}
if (hidif->device->descriptor.iProduct) {
len = usb_get_string_simple(hidif->dev_handle,
hidif->device->descriptor.iProduct, buffer, BUFLEN);
if (len > 0)
fprintf(out, " product: %s\n", buffer);
else
fprintf(out, "(unable to fetch product string)\n");
}
if (hidif->device->descriptor.iSerialNumber) {
len = usb_get_string_simple(hidif->dev_handle,
hidif->device->descriptor.iSerialNumber, buffer, BUFLEN);
if (len > 0)
fprintf(out, " serial number: %s\n", buffer);
else
fprintf(out, "(unable to fetch product string)\n");
}
return HID_RET_SUCCESS;
}
bool M64BirDevice::connectDevice()
{
int err;
char str[100];
// At this point device should point to a valid usb_device if a M64Bir was attached
if( mDevice == NULL )
{
QLOG_ERROR() << "No M64BIR device defined: " << usb_strerror();
return false;
}
// Open the USB device
usb_dev_handle *handle = usb_open( mDevice );
err = usb_set_configuration( handle, 1 );
if( err < 0 )
{
QLOG_ERROR() << "usb_set_configuration() returned " << usb_strerror();
usb_close( handle );
return false;
}
err = usb_claim_interface( handle, 0 );
if( err < 0 )
{
QLOG_ERROR() << "usb_claim_interface() returned " << usb_strerror();
usb_close( handle );
return false;
}
mDeviceHandle = handle;
// Print device information
if( mDevice->descriptor.iManufacturer )
{
err = usb_get_string_simple( mDeviceHandle, mDevice->descriptor.iManufacturer, str, sizeof(str) );
if( err > 0 )
{
mDeviceManufacturer = str;
QLOG_INFO() << "Manufacturer is " << mDeviceManufacturer;
}
}
if( mDevice->descriptor.iProduct )
{
err = usb_get_string_simple( mDeviceHandle, mDevice->descriptor.iProduct, str, sizeof(str) );
if( err > 0 )
{
mDeviceProductName = str;
QLOG_INFO() << "Product is " << mDeviceProductName;
}
}
return true;
}
// ***** Initialize libusb and find matching device *****
// Parameters: none
// Return val: false if failed, true if found
int usbfunk_init( void )
{
int len;
struct usb_bus *bus;
struct usb_device *dev;
const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID};
int vid = rawVid[1] * 256 + rawVid[0];
int pid = rawPid[1] * 256 + rawPid[0];
char vendor[] = {USB_CFG_VENDOR_NAME, '\0'}, product[] = {USB_CFG_DEVICE_NAME, '\0'};
char usb_vendor[256], usb_product[256];
// Init libusb
usb_init();
usb_find_busses();
usb_find_devices();
// Loop through all busses and devices
for (bus = usb_get_busses(); bus; bus = bus->next)
{
for(dev = bus->devices; dev; dev = dev->next)
{
// Check vendor and product id
if(dev->descriptor.idVendor == vid && dev->descriptor.idProduct == pid)
{
// Open device and check strings
handle = usb_open(dev);
if(!handle) continue;
// Check vendor
if(dev->descriptor.iManufacturer > 0)
{
len = usb_get_string_simple(handle, dev->descriptor.iManufacturer, usb_vendor, sizeof(usb_vendor));
if(len < 0) continue;
if(strcmp(vendor, usb_vendor)!=0)
{
usb_close(handle);
continue;
}
}
// Check product
if(dev->descriptor.iProduct > 0)
{
len = usb_get_string_simple(handle, dev->descriptor.iProduct, usb_product, sizeof(usb_product));
if(len < 0) continue;
if(strcmp(product, usb_product)!=0)
{
usb_close(handle);
continue;
}
}
// Device found
return USBFUNK_SUCCESS;
}
}
}
return USBFUNK_DEV_ERROR;
}
int main(int argc, char** argv)
{
std::vector<struct usb_device *> devices;
devices = find_devices(0x0403,0x6001);
if (devices.empty()) {
std::cout << "not found!!!" << std::endl;
return -1;
}
std::cout << devices.size() << " device(s) found." << std::endl;
int ret_val=0;
for( unsigned int i=0; i<devices.size(); i++ )
{
std::cout << std::endl;
std::cout << "Device #" << i << std::endl;
struct usb_device *dev = devices[i];
usb_dev_handle *h = usb_open(dev);
if( h < 0 ) {
std::cerr << "failed to open usb device." << std::endl;
std::cerr << "do with sudo." << std::endl;
}
char buff[128];
int n;
n = usb_get_string_simple(h, dev->descriptor.iManufacturer, buff, 128);
if (n < 0) {
std::cerr << "something is going wrong. do it again with sudo." << std::endl;
ret_val = -1;
continue;
}
std::cout << " Manufacturer : " << std::string(buff) << std::endl;
n = usb_get_string_simple(h, dev->descriptor.iProduct, buff, 128);
if (n < 0) {
std::cerr << "something is going wrong. do it again with sudo." << std::endl;
ret_val = -1;
continue;
}
std::cout << " Product : " << std::string(buff) << std::endl;
n = usb_get_string_simple(h, dev->descriptor.iSerialNumber, buff, 128);
if (n < 0) {
std::cerr << "something is going wrong. do it again with sudo." << std::endl;
ret_val = -1;
continue;
}
std::cout << " Serial Number: " << std::string(buff) << std::endl;
}
return ret_val;
}
void UDMXDevice::extractName()
{
bool needToClose = false;
char name[256];
int len;
Q_ASSERT(m_device != NULL);
if (m_handle == NULL)
{
needToClose = true;
open();
}
/* Check, whether open() was successful */
if (m_handle == NULL)
return;
/* Extract the name */
len = usb_get_string_simple(m_handle, m_device->descriptor.iProduct,
name, sizeof(name));
if (len > 0)
m_name = QString(name);
else
m_name = tr("Unknown");
/* Close the device if it was opened for this function only. */
if (needToClose == true)
close();
}
//-----------------------------------------------------------------------------
bool
cy3240_util_match_serial_number(
struct usb_dev_handle* usbdev,
void* custom,
unsigned int len
)
{
bool ret;
// Allocate a buffer to read the current usb device's serial number
char* buffer = (char*)malloc (len);
// Get the serial number of the specfied device
usb_get_string_simple(
usbdev,
usb_device(usbdev)->descriptor.iSerialNumber,
buffer,
len);
// Compare the current serial number with the one we are looking for
ret = strncmp(buffer, (char*)custom, len) == 0;
// Free the temporary buffer
free(buffer);
// Return the result of the compare
return ret;
}
static int alt_by_name( struct dfu_if *dfu_if, void *v )
{
struct usb_device *dev = dfu_if->dev;
int if_name_str_idx;
char name[MAX_STR_LEN + 1] = "UNDEFINED";
if_name_str_idx =
dev->config[dfu_if->configuration].interface[dfu_if->interface].
altsetting[dfu_if->altsetting].iInterface;
if( !if_name_str_idx )
return 0;
if( !dfu_if->dev_handle )
dfu_if->dev_handle = usb_open( dfu_if->dev );
if( !dfu_if->dev_handle )
return 0;
if( usb_get_string_simple
( dfu_if->dev_handle, if_name_str_idx, name, MAX_STR_LEN ) < 0 )
return 0; /* should we return an error here ? */
if( strcmp( name, v ) )
return 0;
/*
* Return altsetting+1 so that we can use return value 0 to indicate
* "not found".
*/
return dfu_if->altsetting + 1;
}
char * get_usb_string(usb_dev_handle * dev_handle, int index) {
char buffer[256];
char * str;
int result;
if (index == 0)
return NULL;
result = usb_get_string_simple(dev_handle, index, buffer, sizeof(buffer)-1);
if (result < 0) {
avrdude_message(MSG_INFO, "%s: Warning: Failed to read USB device string %d: %s\n",
progname, index, usb_strerror());
return NULL;
}
str = malloc(result+1);
if (str == NULL) {
avrdude_message(MSG_INFO, "%s: Out of memory allocating a string\n", progname);
return 0;
}
memcpy(str, buffer, result);
str[result] = '\0';
return str;
}
int main(void)
{
struct usb_bus *busses;
usb_init();
usb_find_busses();
usb_find_devices();
busses = usb_get_busses();
struct usb_bus *bus;
int c, i, a;
/* ... */
for (bus = busses; bus; bus = bus->next) {
struct usb_device *dev;
int val;
usb_dev_handle *junk;
for (dev = bus->devices; dev; dev = dev->next) {
char buf[1024];
junk = usb_open ( dev );
usb_get_string_simple(junk,2,buf,1023);
if(strncmp(buf,"FT232R",6)==0){
// printf( "reset %p %d (%s)\n", dev, val, buf );
if ( junk == NULL ){
printf("Can't open %p (%s)\n", dev, buf );
} else {
val = usb_reset(junk);
printf( "reset %p %d (%s)\n", dev, val, buf );
}
}
usb_close(junk);
}
}
}
int replay() {
int res = -1;
char buf[256];
usb_dev_handle *udev;
struct usb_device *dev = NULL;
int numeps = 0;
dev = find_first_pvr();
if (dev == NULL) {
fprintf(stderr, "Since no Samsung device in Mass Storage mode found, not going to do anything\n");
return 0;
}
udev = usb_open(dev);
setuid(getuid());
strcpy(buf, "** no string **");
res = usb_get_string_simple(udev, dev->descriptor.iManufacturer, buf, sizeof(buf));
fprintf(stderr, "usb_get_string_simple => %d, %s\n", res, buf);
char blah[254];
memset(blah,0,254);
res = usb_control_msg(udev, USB_TYPE_STANDARD | USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, 0xfe, 0xfe, blah, 0xfe, 1000);
printf("usb_control_msg() = %d\n",res);
fprintf(stderr, "Just switched to 0x2028 now 2034! Custom Product mode\n");
return 0;
}
int usbGetStringAscii(usb_dev_handle *dev, int index, char *buf, int buflen)
{
char buffer[256];
int rval, i;
if((rval = usb_get_string_simple(dev, index, buf, buflen)) >= 0) /* use libusb version if it works */
return rval;
if((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, 0x0409, buffer, sizeof(buffer), 5000)) < 0)
return rval;
if(buffer[1] != USB_DT_STRING){
*buf = 0;
return 0;
}
if((unsigned char)buffer[0] < rval)
rval = (unsigned char)buffer[0];
rval /= 2;
/* lossy conversion to ISO Latin1: */
for(i=1;i<rval;i++){
if(i > buflen) /* destination buffer overflow */
break;
buf[i-1] = buffer[2 * i];
if(buffer[2 * i + 1] != 0) /* outside of ISO Latin1 range */
buf[i-1] = '?';
}
buf[i-1] = 0;
return i-1;
}
/* Returns true if the string descriptor indexed by str_index in device matches string */
static bool string_descriptor_equal(usb_dev_handle *device, uint8_t str_index,
const char *string)
{
int retval;
bool matched;
char desc_string[256+1]; /* Max size of string descriptor */
if (str_index == 0)
return false;
retval = usb_get_string_simple(device, str_index,
desc_string, sizeof(desc_string)-1);
if (retval < 0) {
LOG_ERROR("usb_get_string_simple() 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)
LOG_DEBUG("Device serial number '%s' doesn't match requested serial '%s'",
desc_string, string);
return matched;
}
int usbGetStringAscii(usb_dev_handle *dev, int index, char *buf, int buflen)
{
char buffer[256];
int rval, i;
if((rval = usb_get_string_simple(dev, index, buf, buflen)) >= 0) /* если это работает, используйте версию libusb */
return rval;
if((rval = usb_control_msg(dev, USB_ENDPOINT_IN, USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, 0x0409, buffer, sizeof(buffer), 5000)) < 0)
return rval;
if(buffer[1] != USB_DT_STRING){
*buf = 0;
return 0;
}
if((unsigned char)buffer[0] < rval)
rval = (unsigned char)buffer[0];
rval /= 2;
/* преобразование с потерями в ISO Latin1: */
for(i=1;i<rval;i++){
if(i > buflen) /* переполнение буфера назначения */
break;
buf[i-1] = buffer[2 * i];
if(buffer[2 * i + 1] != 0) /* выход за пределы ISO Latin1 */
buf[i-1] = '?';
}
buf[i-1] = 0;
return i-1;
}
static int print_dfu_if( struct dfu_if *dfu_if, void *v )
{
struct usb_device *dev = dfu_if->dev;
int if_name_str_idx;
char name[MAX_STR_LEN + 1] = "UNDEFINED";
if_name_str_idx = dev->config[dfu_if->configuration]
.interface[dfu_if->interface]
.altsetting[dfu_if->altsetting].iInterface;
if( if_name_str_idx ) {
if( !dfu_if->dev_handle )
dfu_if->dev_handle = usb_open( dfu_if->dev );
if( dfu_if->dev_handle )
usb_get_string_simple( dfu_if->dev_handle,
if_name_str_idx, name, MAX_STR_LEN );
}
printf( "Found %s: [0x%04x:0x%04x] devnum=%u, cfg=%u, intf=%u, "
"alt=%u, name=\"%s\"\n",
dfu_if->flags & DFU_IFF_DFU ? "DFU" : "Runtime",
dev->descriptor.idVendor, dev->descriptor.idProduct,
dev->devnum, dfu_if->configuration, dfu_if->interface,
dfu_if->altsetting, name );
return 0;
}
static int probe_device_descriptor(struct usb_device *dev, FILE *dumpfile)
{
usb_dev_handle *devh;
unsigned char buf[1024];
int i;
int ret;
if (!(dev->descriptor.bDeviceClass == USB_CLASS_PER_INTERFACE ||
dev->descriptor.bDeviceClass == USB_CLASS_PTP ||
dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC) ||
dev->descriptor.idVendor == APPLE_VID) {
return 0;
}
devh = usb_open(dev);
if (devh == NULL) {
return 0;
}
if (dev->config) {
for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
uint8_t j;
for (j = 0; j < dev->config[i].bNumInterfaces; j++) {
int k;
for (k = 0; k < dev->config[i].interface[j].num_altsetting; k++) {
struct usb_interface_descriptor *intf =
&dev->config[i].interface[j].altsetting[k];
buf[0] = '\0';
ret = usb_get_string_simple(devh,
dev->config[i].interface[j].altsetting[k].iInterface,
(char *) buf,
1024);
if (ret < 3)
continue;
if (strcmp((char *) buf, "MTP") == 0) {
if (dumpfile != NULL) {
fprintf(dumpfile, "Configuration %d, interface %d, altsetting %d:\n", i, j, k);
fprintf(dumpfile, " Interface description contains the string \"MTP\"\n");
fprintf(dumpfile, " Device recognized as MTP, no further probing.\n");
}
usb_close(devh);
return 1;
}
}
}
}
}
usb_close(devh);
return 0;
}
bool match_serial_number(struct usb_dev_handle* usbdev, void* custom, unsigned int len)
{
bool ret;
char* buffer = (char*)malloc(len);
usb_get_string_simple(usbdev, usb_device(usbdev)->descriptor.iSerialNumber,buffer, len);
ret = strncmp(buffer, (char*)custom, len) == 0;
free(buffer);
return ret;
}
int get_device_name(struct usb_device *dev, int level, char *rbuf)
{
usb_dev_handle *udev;
char description[256];
char string[256];
int ret,i;
udev = usb_open(dev);
if (udev) {
if (dev->descriptor.iManufacturer) {
ret = usb_get_string_simple(udev, dev->descriptor.iManufacturer, string, sizeof(string));
if (ret > 0)
snprintf(description, sizeof(description), "%s - ", string);
else
snprintf(description, sizeof(description), "%04X - ",
dev->descriptor.idVendor);
} else
snprintf(description, sizeof(description), "%04X - ",
dev->descriptor.idVendor);
if (dev->descriptor.iProduct) {
ret = usb_get_string_simple(udev, dev->descriptor.iProduct, string, sizeof(string));
if (ret > 0)
snprintf(description + strlen(description), sizeof(description) -
strlen(description), "%s", string);
else
snprintf(description + strlen(description), sizeof(description) -
strlen(description), "%04X", dev->descriptor.idProduct);
} else
snprintf(description + strlen(description), sizeof(description) -
strlen(description), "%04X", dev->descriptor.idProduct);
} else
snprintf(description, sizeof(description), "%04X - %04X",
dev->descriptor.idVendor, dev->descriptor.idProduct);
sprintf(rbuf, "%.*sDev #%d: %s", level * 2, " ", dev->devnum,
description);
if (udev)
usb_close(udev);
return 1;
}
struct usb_device * find_dev(void)
{
struct usb_bus *bus;
struct usb_device *dev;
struct usb_dev_handle *handle;
char man[40];
char prod[40];
usb_find_busses();
usb_find_devices();
for(bus = usb_get_busses(); bus; bus = bus->next) {
for(dev = bus->devices; dev; dev = dev->next) {
/* Check for ST Microelectronics vendor ID */
if ((dev->descriptor.idVendor != 0x483) &&
(dev->descriptor.idVendor != 0x1d50))
continue;
handle = usb_open(dev);
usb_get_string_simple(handle, dev->descriptor.iManufacturer, man,
sizeof(man));
usb_get_string_simple(handle, dev->descriptor.iProduct, prod,
sizeof(prod));
#if 0
printf("%s:%s [%04X:%04X] %s : %s\n", bus->dirname, dev->filename,
dev->descriptor.idVendor, dev->descriptor.idProduct, man, prod);
#endif
usb_close(handle);
if (((dev->descriptor.idProduct == 0x5740) ||
(dev->descriptor.idProduct == 0x6018)) &&
!strcmp(man, "Black Sphere Technologies") &&
!strcmp(prod, "Black Magic Firmware Upgrade"))
return dev;
if (((dev->descriptor.idProduct == 0xDF11) ||
(dev->descriptor.idProduct == 0x6017)) &&
!strcmp(man, "Black Sphere Technologies") &&
!strcmp(prod, "Black Magic Probe (Upgrade)"))
return dev;
}
}
return NULL;
}
/*
* Helper function to usbobex_find_interfaces
*/
static int get_intf_string(struct usb_dev_handle *usb_handle, char **string, int id)
{
if (id) {
if ((*string = malloc(USB_MAX_STRING_SIZE)) == NULL)
return -ENOMEM;
*string[0] = '\0';
return usb_get_string_simple(usb_handle, id, *string, USB_MAX_STRING_SIZE);
}
return 0;
}
/*
* Class: ch_ntb_usb_LibusbJava
* Method: usb_get_string_simple
* Signature: (JI)Ljava/lang/String;
*/
JNIEXPORT jstring JNICALL Java_ch_ntb_usb_LibusbJava_usb_1get_1string_1simple
(JNIEnv *env, jclass obj, jlong dev_handle, jint index)
{
clearLibusbJavaError();
char string[256];
int retVal = usb_get_string_simple((usb_dev_handle *) dev_handle, index, string, 256);
if (retVal > 0)
return (*env)->NewStringUTF(env, string);
return 0;
}
int netmd_get_devname(usb_dev_handle* dh, unsigned char* buf, int buffsize)
{
if (usb_get_string_simple(dh, 2, buf, buffsize) < 0) {
fprintf(stderr, "usb_get_string_simple failed, %s (%d)\n", strerror(errno), errno);
buf[0] = 0;
return 0;
}
return strlen(buf);
}
static int libusb_get_string(usb_dev_handle *udev, int StringIdx, char *buf, size_t buflen)
{
int ret;
if (!udev) {
return -1;
}
ret = usb_get_string_simple(udev, StringIdx, buf, buflen);
return libusb_strerror(ret, __func__);
}
int get_usb_string(char *buf, unsigned int len, uint16_t item, usb_dev_handle *handle)
{
char tmp[BUFSIZ];
int ret;
if (!item)
return 0;
ret = usb_get_string_simple(handle, item, tmp, BUFSIZ);
if (ret <= 0)
return ret;
return snprintf(buf, len, "%s", tmp);
}
VALUE get_string_index(VALUE dev, int index)
{
char string[100];
if(index == 0) return rb_str_new2("");
ENSURE_OPEN_BEGIN(dev);
int result = usb_get_string_simple(handle, index, string, 100);
ENSURE_OPEN_END;
if(result < 0) {
raise_usb_error();
}
return rb_str_new2(string);
}
static int get_usb_string(struct xusb *xusb, uint8_t item, char *buf, unsigned int len)
{
char tmp[BUFSIZ];
int ret;
assert(xusb->handle);
if (!item)
return 0;
ret = usb_get_string_simple(xusb->handle, item, tmp, BUFSIZ);
if (ret <= 0)
return ret;
return snprintf(buf, len, "%s", tmp);
}
netmd_error netmd_get_devname(netmd_dev_handle* devh, char* buf, size_t buffsize)
{
int result;
result = usb_get_string_simple((usb_dev_handle *)devh, 2, buf, buffsize);
if (result < 0) {
netmd_log(NETMD_LOG_ERROR, "usb_get_string_simple failed, %s (%d)\n", strerror(errno), errno);
buf[0] = 0;
return NETMD_USB_ERROR;
}
return NETMD_NO_ERROR;
}
uint8_t open_usb(usb_dev_handle **handle) {
uint16_t vid = USB_VID;
uint16_t pid = USB_PID;
char vendor[256];
char product[256];
struct usb_bus *bus;
struct usb_device *dev;
usb_dev_handle *target = NULL;
usb_init();
usb_find_busses();
usb_find_devices();
for (bus=usb_get_busses(); bus; bus=bus->next) {
for (dev=bus->devices; dev; dev=dev->next) {
if (dev->descriptor.idVendor == vid && dev->descriptor.idProduct == pid) {
target = usb_open(dev);
if (target) {
usb_get_string_simple(target, dev->descriptor.iManufacturer, vendor, sizeof(vendor));
usb_get_string_simple(target, dev->descriptor.iProduct, product, sizeof(product));
if (strcmp(vendor, V_NAME) == 0 && strcmp(product, P_NAME) == 0) {
/* we found our device */
break;
}
}
usb_close(target);
target = NULL;
}
}
}
if (target != NULL) {
usb_claim_interface(target, 0);
*handle = target;
return 1;
} else {
return 0;
}
}
