自学教程：C++ usb_get_string_simple函数代码示例

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 boolacr122_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 foundint 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();}

//-----------------------------------------------------------------------------boolcy3240_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;	}}