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

static int switch_dell(struct device_info *devinfo){	char report[] = { 0x7f, 0x13, 0x00, 0x00 };	struct usb_dev_handle *handle;	int err;	handle = usb_open(devinfo->dev);	if (handle) {		usb_claim_interface(handle, 0);		usb_detach_kernel_driver_np(handle, 0);	}	err = usb_control_msg(handle,			USB_ENDPOINT_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,			0x09, 0x7f | (0x03 << 8), 0,			report, sizeof(report), 10000);	if (err == 0) {		err = -1;		errno = EALREADY;	} else {		if (errno == ETIMEDOUT)			err = 0;	}	usb_close(handle);	return err;}

int init(void){	struct usb_device *dev;	dev = find_device();	if (dev == NULL) {		printf("not found/n");		goto cleanup;	}	handle = usb_open(dev);	if (handle == NULL)		goto cleanup;	usb_detach_kernel_driver_np(handle, 0);	if (usb_set_configuration(handle, 1) < 0)		goto cleanup;	if (usb_claim_interface(handle, 0) < 0)		goto cleanup;//if (usb_set_altinterface(handle, 2) < 0)	//goto cleanup;	return 0; cleanup:	assert(0);	return 0;}

static int open_interface(struct rf2500_transport *tr,			  struct usb_device *dev, int ino){	printc("Trying to open interface %d on %s/n", ino, dev->filename);	tr->int_number = ino;	tr->handle = usb_open(dev);	if (!tr->handle) {		pr_error("rf2500: can't open device");		return -1;	}#if defined(__linux__)	if (usb_detach_kernel_driver_np(tr->handle, tr->int_number) < 0)		pr_error("rf2500: warning: can't "			"detach kernel driver");#endif#ifdef WIN32	if (usb_set_configuration(tr->handle, 1) < 0) {		pr_error("rf2500: can't set configuration 1");		usb_close(tr->handle);		return -1;	}#endif	if (usb_claim_interface(tr->handle, tr->int_number) < 0) {		pr_error("rf2500: can't claim interface");		usb_close(tr->handle);		return -1;	}	return 0;}

static usb_dev_handle *get_ir(void){	static usb_dev_handle *ir = NULL;	if (!ir) {		usb_init();		usb_find_busses();		usb_find_devices();		ir = find_ir();		if (!ir) {			fprintf(stderr, "IR receiver not found, quitting/n");			exit(1);		}		/* interface is normally handled by hiddev */		usb_detach_kernel_driver_np(ir, 0);		if (usb_claim_interface(ir, 0)) {			fprintf(stderr, "error claiming interface, are you root?/n");			exit(2);		}		//usb_reset(ir);		//usb_set_configuration(ir, 0);	}	return ir;}

int main(int argc, char **argv){  usb_dev_handle      *handle = NULL;  const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID};  char                vendor[] = {USB_CFG_VENDOR_NAME, 0}, product[] = {USB_CFG_DEVICE_NAME, 0};  char                buffer[50] = "";  unsigned char	      request;  int                 vid, pid, nBytes;  usb_init();  if(argc < 2){   /* we need at least one argument */    printf("Arguments Missing");    exit(1);  }  request = atoi(argv[1]);    /* compute VID/PID from usbconfig.h so that there is a central source of information */  vid = rawVid[1] * 256 + rawVid[0];  pid = rawPid[1] * 256 + rawPid[0];    /* The following function is in opendevice.c: */  if(usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) != 0){    fprintf(stderr, "Could not find USB device /"%s/" with vid=0x%x pid=0x%x/n", product, vid, pid);    exit(1);  }    /* Since we use only control endpoint 0, we don't need to choose a     * configuration and interface. Reading device descriptor and setting a     * configuration and interface is done through endpoint 0 after all.     * However, newer versions of Linux require that we claim an interface     * even for endpoint 0. Enable the following code if your operating system     * needs it: */#if 0  int retries = 1, usbConfiguration = 1, usbInterface = 0;  if(usb_set_configuration(handle, usbConfiguration) && showWarnings){    fprintf(stderr, "Warning: could not set configuration: %s/n", usb_strerror());  }    /* now try to claim the interface and detach the kernel HID driver on     * Linux and other operating systems which support the call. */  while((len = usb_claim_interface(handle, usbInterface)) != 0 && retries-- > 0){#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP    if(usb_detach_kernel_driver_np(handle, 0) < 0 && showWarnings){      fprintf(stderr, "Warning: could not detach kernel driver: %s/n", usb_strerror());    }#endif  }#endif  nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT, request, 0, 0, (char *)buffer, sizeof(buffer), 5000);				  if(nBytes < 0)    printf("error in USB control transfer: %s/n", usb_strerror());				  usb_close(handle);  return 0;}

int detach_driver(struct usb_dev_handle *handle, int interface_number){	int r;	r = usb_detach_kernel_driver_np(handle, interface_number);	r = usb_return(((r == -61)? 0 : r), "detach_driver: usb_detach_kernel_driver_np");		return r;}

intusbClaimInterface (UsbDevice *device, unsigned char interface) {  UsbDeviceExtension *devx = device->extension;  int detached = 0;  int result;  logMessage(LOG_CATEGORY(USB_IO), "claiming interface: %u", interface);  while (1) {    char driver[0X100];    result = usb_claim_interface(devx->handle, interface);    if (result >= 0) return 1;    if (result != -EBUSY) break;    if (detached) break;#ifdef LIBUSB_HAS_GET_DRIVER_NP    result = usb_get_driver_np(devx->handle, interface, driver, sizeof(driver));    if (result < 0)#endif /* LIBUSB_HAS_GET_DRIVER_NP */    {      strcpy(driver, "unknown");    }    logMessage(LOG_WARNING, "USB interface in use: %u (%s)", interface, driver);    if (strcmp(driver, "usbfs") == 0) {      result = -EBUSY;      break;    }#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP    logMessage(LOG_CATEGORY(USB_IO), "detaching kernel driver: %u (%s)",               interface, driver);    result = usb_detach_kernel_driver_np(devx->handle, interface);    if (result >= 0) {      logMessage(LOG_CATEGORY(USB_IO), "detached kernel driver: %u (%s)",                 interface, driver);      detached = 1;      continue;    }    result = -EBUSY;#endif /* LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP */    break;  }  errno = -result;  logSystemError("USB interface claim");  return 0;}

static intgp_port_usb_open (GPPort *port){	int ret;	char name[64];	gp_log (GP_LOG_DEBUG,"libusb","gp_port_usb_open()");	if (!port || !port->pl->d)		return GP_ERROR_BAD_PARAMETERS;        /*	 * Open the device using the previous usb_handle returned by	 * find_device	 */	port->pl->dh = usb_open (port->pl->d);	if (!port->pl->dh) {		gp_port_set_error (port, _("Could not open USB device (%m)."));		return GP_ERROR_IO;	}#if defined(LIBUSB_HAS_GET_DRIVER_NP) && defined(LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP)	memset(name,0,sizeof(name));	ret = usb_get_driver_np (port->pl->dh, port->settings.usb.interface,		name, sizeof(name)	);	if (strstr(name,"usbfs") || strstr(name,"storage")) {		/* other gphoto instance most likely		 * Also let mass storage be served by regular means.		 */		gp_port_set_error (port, _("Camera is already in use."));		return GP_ERROR_IO_LOCK;	}	if (ret >= 0) {		gp_log (GP_LOG_DEBUG,"libusb",_("Device has driver '%s' attached, detaching it now."), name);		ret = usb_detach_kernel_driver_np (port->pl->dh, port->settings.usb.interface);		if (ret < 0)			gp_port_set_error (port, _("Could not detach kernel driver '%s' of camera device."),name);		else			port->pl->detached = 1;	} else {		if (errno != ENODATA) /* ENODATA - just no driver there */			gp_port_set_error (port, _("Could not query kernel driver of device."));	}#endif	gp_log (GP_LOG_DEBUG,"libusb","claiming interface %d", port->settings.usb.interface);	ret = usb_claim_interface (port->pl->dh,				   port->settings.usb.interface);	if (ret < 0) {		gp_port_set_error (port, _("Could not claim "			"interface %d (%m). Make sure no other program "			"or kernel module (such as %s) is using the device "			"and you have read/write access to the device."),			port->settings.usb.interface, "sdc2xx, stv680, spca50x");		return GP_ERROR_IO_USB_CLAIM;	}	return GP_OK;}

usb_dev_handle *m4Init() {  struct usb_bus *bus;  struct usb_device *dev;  usb_init();  if (usb_find_busses() < 0) {    return NULL;  }  if (usb_find_devices() < 0) {    return NULL;  }  bus = usb_get_busses();  while (bus) {    dev = bus->devices;    while (dev) {      if (dev->descriptor.idVendor == VENDOR &&          dev->descriptor.idProduct == PRODUCT) {	usb_dev_handle *handle = usb_open(dev);	if (handle) {#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP          /* Linux usually claims HID devices for its usbhid driver. */          usb_detach_kernel_driver_np(handle, 0);#endif	  if (usb_set_configuration(handle, 1) >= 0) {	    if (usb_claim_interface(handle, 0) >= 0) {	      if (usb_set_altinterface(handle, 0) < 0) {	        usb_close(handle);		return NULL;              }	    } else {	      usb_close(handle);	      return NULL;	    }	  } else {	    usb_close(handle);	    return NULL;	  }	  return handle;	}      }      dev = dev->next;    }    bus = bus->next;  }  return NULL;}

voidwrite_usb_device(struct usb_device* dev, int interface, int endpoint){  struct usb_dev_handle* handle = usb_open(dev);  if (!handle)    {      std::cout << "Error opening usb device" << std::endl;    }  else    {      if (usb_claim_interface(handle, interface) != 0)        {          std::cout << "Error claiming the interface: " << usb_strerror() << std::endl;          if (usb_detach_kernel_driver_np(handle, interface) < 0)            {              std::cout << "Failure to kick kernel driver: " << usb_strerror() << std::endl;              exit(EXIT_FAILURE);                          }          if (usb_claim_interface(handle, interface) != 0)            {              std::cout << "Error claiming the interface: " << usb_strerror() << std::endl;              exit(EXIT_FAILURE);            }        }      bool quit = false;      while(!quit)        {          uint8_t data[32];                    if (1)            {              int ret = fread(data, sizeof(char), sizeof(data), stdin);              std::cout << ret << std::endl;              usb_interrupt_write(handle, endpoint, (char*)data, ret, 0);            }          else            {              int ret = sizeof(data);              for(int i = 0; i < ret ; ++i)                {                  data[i] = int(127 * sin(float(i) / ret * M_PI*2)) + 127;                  std::cout << ret << std::endl;                }              std::cout << ret << std::endl;              usb_interrupt_write(handle, endpoint, (char*)data, ret, 0);            }        }    }   }

static int open_interface(struct cp210x_transport *tr,			  struct usb_device *dev, int ino,			  int baud_rate){#if defined(__linux__)	int drv;	char drName[256];#endif	printc_dbg(__FILE__": Trying to open interface %d on %s/n",	       ino, dev->filename);	tr->int_number = ino;	tr->handle = usb_open(dev);	if (!tr->handle) {		pr_error(__FILE__": can't open device");		return -1;	}#if defined(__linux__)	drv = usb_get_driver_np(tr->handle, tr->int_number, drName,				sizeof(drName));	printc(__FILE__" : driver %d/n", drv);	if (drv >= 0) {		if (usb_detach_kernel_driver_np(tr->handle,						tr->int_number) < 0)			pr_error(__FILE__": warning: can't detach "			       "kernel driver");	}#endif#ifdef __Windows__	if (usb_set_configuration(tr->handle, 1) < 0) {		pr_error(__FILE__": can't set configuration 1");		usb_close(tr->handle);		return -1;	}#endif	if (usb_claim_interface(tr->handle, tr->int_number) < 0) {		pr_error(__FILE__": can't claim interface");		usb_close(tr->handle);		return -1;	}	if (configure_port(tr, baud_rate) < 0) {		printc_err("Failed to configure for V1 device/n");		usb_close(tr->handle);		return -1;	}	return 0;}

int send_command(usb_dev_handle *handle, cmdstruct command ) {    if (command.numCmds == 0) {        printf( "send_command: Empty command provided! Not sending anything.../n");        return 0;    }    int stat;    stat = usb_detach_kernel_driver_np(handle, 0);    if ((stat < 0 ) || verbose_flag) perror("Detach kernel driver");    stat = usb_claim_interface( handle, 0 );    if ( (stat < 0) || verbose_flag) perror("Claiming USB interface");    int transferred = 0;    // send all command strings provided in command    int cmdCount;    for (cmdCount=0; cmdCount < command.numCmds; cmdCount++) {        if (verbose_flag) {            char raw_string[255];            print_cmd(raw_string, command.cmds[cmdCount]);            printf("/tSending string:   /"%s/"/n", raw_string);        }        stat = usb_interrupt_write( handle, 1, (const char*)command.cmds[cmdCount], sizeof( command.cmds[cmdCount] ), TRANSFER_WAIT_TIMEOUT_MS );        transferred = (stat>0)?stat:0;        if ( (stat < 0) || verbose_flag) perror("Sending USB command");    }    /* In case the command just sent caused the device to switch from restricted mode to native mode     * the following two commands will fail due to invalid device handle (because the device changed     * its pid on the USB bus).     * So it is not possible anymore to release the interface and re-attach kernel driver.     * I am not sure if this produces a memory leak within libusb, but i do not think there is another     * solution possible...     */    stat = usb_release_interface(handle, 0 );/*FIXME:    if (stat != usb_ERROR_NO_DEVICE) { // silently ignore "No such device" error due to reasons explained above.        if ( (stat < 0) || verbose_flag) {            perror("Releasing USB interface.");        }    }*///FIXME: Not portable?!    stat = usb_attach_kernel_driver_np( handle, 0);/*FIXME:    if (stat != usb_ERROR_NO_DEVICE) { // silently ignore "No such device" error due to reasons explained above.        if ( (stat < 0) || verbose_flag) {            perror("Reattaching kernel driver");        }    }*/    return 0;}

/* USB::DevHandle#usb_detach_kernel_driver_np(interface) */static VALUErusb_detach_kernel_driver_np(  VALUE v,  VALUE vinterface){  usb_dev_handle *p = get_usb_devhandle(v);  int interface = NUM2INT(vinterface);  int ret;  ret = usb_detach_kernel_driver_np(p, interface);  check_usb_error("usb_detach_kernel_driver_np", ret);  return Qnil;}

usb_dev_handle * open_usb_device(int vid, int pid){	struct usb_bus *bus;	struct usb_device *dev;	usb_dev_handle *h;	char buf[128];	int r;	usb_init();	usb_find_busses();	usb_find_devices();	//printf_verbose("/nSearching for USB device:/n");	for (bus = usb_get_busses(); bus; bus = bus->next) {		for (dev = bus->devices; dev; dev = dev->next) {			//printf_verbose("bus /"%s/", device /"%s/" vid=%04X, pid=%04X/n",			//	bus->dirname, dev->filename,			//	dev->descriptor.idVendor,			//	dev->descriptor.idProduct			//);			if (dev->descriptor.idVendor != vid) continue;			if (dev->descriptor.idProduct != pid) continue;			h = usb_open(dev);			if (!h) {				printf_verbose("Found device but unable to open");				continue;			}			#ifdef LIBUSB_HAS_GET_DRIVER_NP			r = usb_get_driver_np(h, 0, buf, sizeof(buf));			if (r >= 0) {				r = usb_detach_kernel_driver_np(h, 0);				if (r < 0) {					usb_close(h);					printf_verbose("Device is in use by /"%s/" driver", buf);					continue;				}			}			#endif			// Mac OS-X - removing this call to usb_claim_interface() might allow			// this to work, even though it is a clear misuse of the libusb API.			// normally Apple's IOKit should be used on Mac OS-X			r = usb_claim_interface(h, 0);			if (r < 0) {				usb_close(h);				printf_verbose("Unable to claim interface, check USB permissions");				continue;			}			return h;		}	}	return NULL;}

/* * detaches the kernel from a particular USB interface.  The kernel tends to * claim HID devices it recognises, so if you want to utilitize the device * directly through libusb you must first detach the kernel.  This stop the * device from acting like a regular linux mouse or keyboard and let you utilize * it directly */VALUE interface_detach_kernel(VALUE self){  if(interface_is_claimable(self) == Qtrue) return Qnil;  struct usb_interface_descriptor* interface;  Data_Get_Struct(self, struct usb_interface_descriptor, interface);  ENSURE_OPEN_BEGIN(rb_iv_get(self, "@device"));  int result = usb_detach_kernel_driver_np(handle, interface->bInterfaceNumber);  ENSURE_OPEN_END;  if(result < 0) {    raise_usb_error();  }  return Qnil;}

void *_ykusb_open_device(int vendor_id, int *product_ids, size_t pids_len){	struct usb_bus *bus;	struct usb_device *yk_device;	struct usb_dev_handle *h = NULL;	int rc = YK_EUSBERR;	int found = 0;	for (bus = usb_get_busses(); bus; bus = bus->next) {		struct usb_device *dev;		rc = YK_ENOKEY;		for (dev = bus->devices; dev; dev = dev->next) {			if (dev->descriptor.idVendor == vendor_id) {				size_t j;				for (j = 0; j < pids_len; j++) {					if (dev->descriptor.idProduct == product_ids[j]) {						if(found == 0) {							yk_device = dev;							found = 1;							break;						} else {							rc = YK_EMORETHANONE;							goto done;						}					}				}			}		}	}	if(found == 1) {		rc = YK_EUSBERR;		h = usb_open(yk_device);#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP		if (h != NULL)			usb_detach_kernel_driver_np(h, 0);#endif		/* This is needed for yubikey-personalization to work inside virtualbox virtualization. */		if (h != NULL)			usb_set_configuration(h, 1);		goto done;	} done:	if (h == NULL)		yk_errno = rc;	return h;}

static int handle_device(int dev_id){  int r, i;  struct usb_device *dev = g_devices[dev_id].usb_dev;  usb_dev_handle *hdev = g_devices[dev_id].hdev;  usb_detach_kernel_driver_np(hdev, 0);    if( 0 != (r = usb_set_configuration(hdev, dev->config[0].bConfigurationValue)) )  {    printf("usb_set_configuration returns %d (%s)/n", r, usb_strerror());    return -1;  }  if((r = usb_claim_interface(hdev, 0)) < 0)  {    printf("Interface cannot be claimed: %d/n", r);    return r;  }  int nep = dev->config->interface->altsetting->bNumEndpoints;  for(i=0; i<nep; i++)  {    int ep = dev->config->interface->altsetting->endpoint[i].bEndpointAddress;    if(ep&(1<<7))      g_devices[dev_id].epin = ep;    else      g_devices[dev_id].epout = ep;  }  // Set baudrate  int baudrate = 250000;  r = usb_control_msg(hdev, USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_ENDPOINT_OUT,                       CP210X_IFC_ENABLE, UART_ENABLE, 0, NULL, 0, 500);  r = usb_control_msg(hdev, USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_ENDPOINT_OUT,                       CP210X_SET_BAUDRATE, 0, 0, (char *)&baudrate, sizeof(baudrate), 500);  r = usb_control_msg(hdev, USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_ENDPOINT_OUT,                       CP210X_IFC_ENABLE, UART_DISABLE, 0, NULL, 0, 500);  // read/write main loop  io_loop(dev_id);   usb_release_interface(hdev, 0);  return 0;}

voidread_usb_device(struct usb_device* dev, int interface, int endpoint){  struct usb_dev_handle* handle = usb_open(dev);  if (!handle)    {      std::cout << "Error opening usb device" << std::endl;    }  else    {      if (usb_claim_interface(handle, interface) != 0)        {          std::cout << "Error claiming the interface: " << usb_strerror() << std::endl;          if (usb_detach_kernel_driver_np(handle, interface) < 0)            {              std::cout << "Failure to kick kernel driver: " << usb_strerror() << std::endl;              exit(EXIT_FAILURE);                          }          if (usb_claim_interface(handle, interface) != 0)            {              std::cout << "Error claiming the interface: " << usb_strerror() << std::endl;              exit(EXIT_FAILURE);            }        }      bool quit = false;      while(!quit)        {          uint8_t data[8192];          int ret = usb_interrupt_read(handle, endpoint, (char*)data, sizeof(data), 0);          if (ret < 0)            {              std::cerr << "USBError: " << ret << "/n" << usb_strerror() << std::endl;              std::cerr << "Shutting down" << std::endl;              quit = true;            }          fwrite(data, sizeof(char), ret, stdout);        }    }  }

int main(int argc, char **argv){	unsigned int count = 0U, removed = 0U;	struct usb_bus *bus;	struct usb_device *dev;	static usb_dev_handle *handle;	char name[256];	usb_init();	usb_find_busses();	usb_find_devices();	for (bus = usb_get_busses(); bus != NULL; bus = bus->next) {		for (dev = bus->devices; dev != NULL; dev = dev->next) {			if (dev->descriptor.idVendor == C108_VENDOR_ID &&			   (dev->descriptor.idProduct == C108_PRODUCT_ID   ||			    dev->descriptor.idProduct == C108AH_PRODUCT_ID ||			    dev->descriptor.idProduct == C119_PRODUCT_ID)) {				count++;				if ((handle = usb_open(dev)) == NULL) {					fprintf(stderr, "rmuridrv: cannot open the USB device: %s/n", usb_strerror());					continue;				}				memset(name, 0, 256);				if (usb_get_driver_np(handle, CM108_INTERFACE, name, 256) == 0) {					if (strcmp(name, "usbhid") == 0) {						if (usb_detach_kernel_driver_np(handle, CM108_INTERFACE) == 0)							removed++;						else							fprintf(stderr, "rmuridrv: could not disconnect from usbhid: %s/n", usb_strerror());					}				}				usb_close(handle);			}		}	}	fprintf(stdout, "rmuridrv: found %u CM108 devices and removed %u from the usbhid driver/n", count, removed);	return 0;}

static int open_device(struct bslhid_transport *tr, struct usb_device *dev){	if (find_interface(tr, dev) < 0)		return -1;	printc_dbg("Opening interface %d (config %d).../n",		   tr->int_number, tr->cfg_number);	if (find_endpoints(tr, dev) < 0)		return -1;	printc_dbg("Found endpoints: IN: 0x%02x, OUT: 0x%02x/n",		   tr->in_ep, tr->out_ep);	tr->handle = usb_open(dev);	if (!tr->handle) {		pr_error("bslhid: can't open device");		return -1;	}#ifdef __Windows__	if (usb_set_configuration(tr->handle, tr->cfg_number) < 0)		pr_error("warning: bslhid: can't set configuration");#endif#ifdef __linux__	if (usb_detach_kernel_driver_np(tr->handle, tr->int_number) < 0)		pr_error("warning: bslhid: can't detach kernel driver");#endif	if (usb_claim_interface(tr->handle, tr->int_number) < 0) {		pr_error("bslhid: can't claim interface");		usb_close(tr->handle);		return -1;	}	/* Save the bus path for a future suspend/resume */	strncpy(tr->bus_name, dev->bus->dirname, sizeof(tr->bus_name));	tr->bus_name[sizeof(tr->bus_name) - 1] = 0;	return 0;}

MyDriver::MyDriver() {	const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID};	char vendor[] = {USB_CFG_VENDOR_NAME, 0}, product[] = {USB_CFG_DEVICE_NAME, 0};	int vid, pid;	handle=NULL;	usb_init();	// compute VID/PID from usbconfig.h so that there is a central source of information	vid = rawVid[1] * 256 + rawVid[0];	pid = rawPid[1] * 256 + rawPid[0];	// The following function is in opendevice.c: */	if(usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) != 0){		fprintf(stderr, "Could not find USB device /"%s/" with vid=0x%x pid=0x%x/n", product, vid, pid);	    exit(1);	}	// Since we use only control endpoint 0, we don't need to choose a	// configuration and interface. Reading device descriptor and setting a	// configuration and interface is done through endpoint 0 after all.	// However, newer versions of Linux require that we claim an interface	// even for endpoint 0. Enable the following code if your operating system	// needs it#if 0	int retries = 1, usbConfiguration = 1, usbInterface = 0;	if(usb_set_configuration(handle, usbConfiguration) && showWarnings){		fprintf(stderr, "Warning: could not set configuration: %s/n", usb_strerror());	}	// now try to claim the interface and detach the kernel HID driver on	// Linux and other operating systems which support the call.	while((len = usb_claim_interface(handle, usbInterface)) != 0 && retries-- > 0){#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP		if(usb_detach_kernel_driver_np(handle, 0) < 0 && showWarnings){			fprintf(stderr, "Warning: could not detach kernel driver: %s/n", usb_strerror());		}#endif	}#endif}

int main(void){//	printf("SizeOF %ld/n", sizeof(struct usb_dev_handle*));    libusb_init();    libusb_set_debug(2);    libusb_find_busses();    libusb_find_devices();	struct usb_dev_handle* green = malloc(256);	green = get_green(bus, dev);	printf("Detach: %d/n", usb_detach_kernel_driver_np(green, 0));	printf("Halt: %d/n", usb_clear_halt(green, 0x81));	printf("Interface: %d/n", usb_claim_interface(green, 0));	libusb_alloc_transfer(0);	   //	printf("Buffer: %x/n", buffer);	return 0;}

void usb_detach(usb_dev_handle *lvr_winusb, int iInterface) {        int ret; 	ret = usb_detach_kernel_driver_np(lvr_winusb, iInterface);	if(ret) {		if(errno == ENODATA) {			if(debug) {				printf("Device already detached/n");			}		} else {			if(debug) {				printf("Detach failed: %s[%d]/n",				       strerror(errno), errno);				printf("Continuing anyway/n");			}		}	} else {		if(debug) {			printf("detach successful/n");		}	}} 

void process_device(int argc, char **argv, struct usb_device *dev,		    struct usb_config_descriptor *cfg, int itfnum) {  int mac[6];  usb_dev_handle *devh = usb_open(dev);  if ( ! devh ) fatal("usb_open");  usb_detach_kernel_driver_np(devh, itfnum);  int res = usb_claim_interface(devh, itfnum);  if ( res < 0 ) fatal("usb_claim_interface");  show_master(devh, itfnum);  if ( argc >= 2 ) {    if ( sscanf(argv[1], "%x:%x:%x:%x:%x:%x",		&mac[0],&mac[1],&mac[2],&mac[3],&mac[4],&mac[5]) != 6 ) {      printf("usage: %s [<bd_addr of master>]/n", argv[0]);      exit(1);    }  } else {    FILE *f = popen("hcitool dev", "r");    if ( !f ||	 fscanf(f, "%*s/n%*s %x:%x:%x:%x:%x:%x",		&mac[0],&mac[1],&mac[2],&mac[3],&mac[4],&mac[5]) != 6 ) {      printf("Unable to retrieve local bd_addr from `hcitool dev`./n");      printf("Please enable Bluetooth or specify an address manually./n");      exit(1);    }    pclose(f);  }      set_master(devh, itfnum, mac);  usb_reset(devh);  usb_release_interface(devh, itfnum);  usb_close(devh);}

void *_ykusb_open_device(int vendor_id, int product_id){	struct usb_bus *bus;	struct usb_device *dev;	struct usb_dev_handle *h = NULL;	int rc = YK_EUSBERR;	for (bus = usb_get_busses(); bus; bus = bus->next) {		rc = YK_ENOKEY;		for (dev = bus->devices; dev; dev = dev->next)			if (dev->descriptor.idVendor == YUBICO_VID			    && dev->descriptor.idProduct == YUBIKEY_PID) {				rc = YK_EUSBERR;				h = usb_open(dev);				if (h != NULL)					usb_detach_kernel_driver_np(h, 0);				goto done;			}	} done:	if (h == NULL)		yk_errno = rc;	return h;}

usb_dev_handle* setup_libusb_access() {     usb_dev_handle *lvr_winusb;     usb_set_debug(0);     usb_init();     usb_find_busses();     usb_find_devices();     if(!(lvr_winusb = find_lvr_winusb())) {                return NULL;        }/* Linux*/usb_detach_kernel_driver_np(lvr_winusb,0);        if (usb_set_configuration(lvr_winusb, 1) < 0) {                printf("Could not set configuration 1 : /n");                return NULL;        }         if (usb_claim_interface(lvr_winusb, INTFACE) < 0) {                printf("Could not claim interface: /n");                return NULL;        }        return lvr_winusb; }

usb_dev_handle* OpenProxmark(int verbose){  int ret;  usb_dev_handle *handle = NULL;  unsigned int iface;  handle = findProxmark(verbose, &iface);  if (!handle)    return NULL;#ifdef __linux__  /* detach kernel driver first */  ret = usb_detach_kernel_driver_np(handle, iface);  /* don't complain if no driver attached */  if (ret<0 && ret != -61 && verbose)    fprintf(stderr, "detach kernel driver failed: (%d) %s!/n", ret, usb_strerror());#endif  // Needed for Windows. Optional for Mac OS and Linux  ret = usb_set_configuration(handle, 1);  if (ret < 0) {    if (verbose)      fprintf(stderr, "configuration set failed: %s!/n", usb_strerror());    return NULL;  }  ret = usb_claim_interface(handle, iface);  if (ret < 0) {    if (verbose)      fprintf(stderr, "claim failed: %s!/n", usb_strerror());    return NULL;  }  claimed_iface = iface;  devh = handle;  return handle;}

static int drv_MOGX_open(void){    struct usb_bus *busses, *bus;    struct usb_device *dev;    char driver[1024];    char product[1024];    char manufacturer[1024];    char serialnumber[1024];    int ret;    lcd_dev = NULL;    info("%s: scanning for Matrix Orbital GX Series LCD...", Name);    usb_set_debug(0);    usb_init();    usb_find_busses();    usb_find_devices();    busses = usb_get_busses();    for (bus = busses; bus; bus = bus->next) {	for (dev = bus->devices; dev; dev = dev->next) {	    if ((dev->descriptor.idVendor == MatrixOrbitalGX_VENDOR) &&		((dev->descriptor.idProduct == MatrixOrbitalGX_DEVICE_1) ||		 (dev->descriptor.idProduct == MatrixOrbitalGX_DEVICE_2) ||		 (dev->descriptor.idProduct == MatrixOrbitalGX_DEVICE_3))) {		/* At the moment, I have information for only this LCD */		if (dev->descriptor.idProduct == MatrixOrbitalGX_DEVICE_2)		    backlight_RGB = 0;		info("%s: found Matrix Orbital GX Series LCD on bus %s device %s", Name, bus->dirname, dev->filename);		lcd_dev = usb_open(dev);		ret = usb_get_driver_np(lcd_dev, 0, driver, sizeof(driver));		if (ret == 0) {		    info("%s: interface 0 already claimed by '%s'", Name, driver);		    info("%s: attempting to detach driver...", Name);		    if (usb_detach_kernel_driver_np(lcd_dev, 0) < 0) {			error("%s: usb_detach_kernel_driver_np() failed!", Name);			return -1;		    }		}		usb_set_configuration(lcd_dev, 1);		usleep(100);		if (usb_claim_interface(lcd_dev, 0) < 0) {		    error("%s: usb_claim_interface() failed!", Name);		    return -1;		}		usb_set_altinterface(lcd_dev, 0);		usb_get_string_simple(lcd_dev, dev->descriptor.iProduct, product, sizeof(product));		usb_get_string_simple(lcd_dev, dev->descriptor.iManufacturer, manufacturer, sizeof(manufacturer));		usb_get_string_simple(lcd_dev, dev->descriptor.iSerialNumber, serialnumber, sizeof(serialnumber));		info("%s: Manufacturer='%s' Product='%s' SerialNumber='%s'", Name, manufacturer, product, serialnumber);		return 0;	    }	}    }    error("%s: could not find a Matrix Orbital GX Series LCD", Name);    return -1;}

int main(int argc, char *argv[]){	struct usb_bus *bus;	struct usb_device *dev, *mydev;	usb_dev_handle *handle;	unsigned char bytes[64];	int ret;	int i; 	for (ret = 0; ret < 64; ret++) {		 bytes[ret] = 0;	}	bytes[0] = 0; 	bytes[1] = 0; 	bytes[2] = 0; 	bytes[3] = 0; 	bytes[4] = 0; 	bytes[5] = 0; 	bytes[6] = 0x01; 	bytes[7] = 0xbb; 	usb_init();	usb_find_busses();	usb_find_devices();	for (bus = usb_busses; bus; bus = bus->next) {		for (dev = bus->devices; dev; dev = dev->next) {			if (dev->descriptor.idVendor == 0x1130 && dev->descriptor.idProduct == 0x6807) {				printf("find my device/n");				mydev = dev;				break;			}		}	}	handle = usb_open(mydev);	printf("handle = %d/n", handle);	//usb_get_driver_np(handle, 0, bytes, 64); 	//fprintf(stderr,  "return usb_get_driver name is %s/n",  bytes); #if 1	ret = usb_detach_kernel_driver_np(handle, 1); 	fprintf(stderr,  "usb_detach_kernel_driver_np return %d/n",  ret); 	ret = usb_claim_interface(handle, 1);	printf("claim interface return %d/n",  ret); #endif	#if 1	ret = usb_detach_kernel_driver_np(handle, 0); 	fprintf(stderr,  "return usb_detach_kernel_driver_np is %d/n",  ret); 	ret = usb_claim_interface(handle, 0);	printf("claim interface return %d/n",  ret); #endif	ret = usb_control_msg(handle, 0x21, 0x09,	0x0200, 1, bytes, 0x0008, 1000);	printf("usb_control_msg return %d/n",  ret); 	sleep(1); 	ret = usb_interrupt_read(handle, 3, bytes, 64,  1000); 	printf("usb_interrupt_read return %d/n",  ret); 	for (i = 0;  i < 64;  i++) {		printf("0x%02x ", bytes[i]); 	}	printf("/n"); 	usb_release_interface(handle, 0); 	usb_release_interface(handle, 1); 	usb_close(handle); 	return 0;}

/** * API: Initialize glcd2usb connection type. */intglcd2usb_init(Driver *drvthis){	PrivateData *p = (PrivateData *)drvthis->private_data;	CT_glcd2usb_data *ctd;	static int didUsbInit = 0;	struct usb_bus *bus;	struct usb_device *dev;	usb_dev_handle *handle = NULL;	int err = 0;	int rval, retries = 3;	int len;	/* Set up connection type low-level functions */	p->glcd_functions->blit = glcd2usb_blit;	p->glcd_functions->close = glcd2usb_close;	p->glcd_functions->set_backlight = glcd2usb_backlight;	p->glcd_functions->poll_keys = glcd2usb_poll_keys;	/* Allocate memory structures */	ctd = (CT_glcd2usb_data *) calloc(1, sizeof(CT_glcd2usb_data));	if (ctd == NULL) {		report(RPT_ERR, "%s/glcd2usb: error allocating connection data", drvthis->name);		return -1;	}	p->ct_data = ctd;	/*	 * Try to find and open a device. Only the first device found will be	 * recognized.	 */	if (!didUsbInit) {		usb_init();		didUsbInit = 1;	}	usb_find_busses();	usb_find_devices();	for (bus = usb_get_busses(); bus != NULL; bus = bus->next) {		for (dev = bus->devices; dev != NULL; dev = dev->next) {			if (dev->descriptor.idVendor == GLCD2USB_VID			    && dev->descriptor.idProduct == GLCD2USB_PID) {				handle = usb_open(dev);				if (!handle) {					report(RPT_WARNING, "%s/glcd2usb: cannot open USB device: %s",					       drvthis->name, usb_strerror());					continue;				}				else {					goto found_dev;				}			}		}	}found_dev:	if (handle) {		debug(RPT_DEBUG, "%s/glcd2usb: opening device succeeded", drvthis->name);	}	else {		report(RPT_ERR, "%s/glcd2usb: no GLCD2USB device found", drvthis->name);		goto err_out;	}	if (usb_set_configuration(handle, 1))		report(RPT_WARNING, "%s/glcd2usb: could not set configuration: %s",		       drvthis->name, usb_strerror());	/*	 * now try to claim the interface and detach the kernel HID driver on	 * Linux and other operating systems which support the call.	 */	while ((rval = usb_claim_interface(handle, 0)) != 0 && retries-- > 0) {#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP		if (usb_detach_kernel_driver_np(handle, 0) < 0) {			report(RPT_WARNING, "%s/glcd2usb: could not detach kernel HID driver: %s",			       drvthis->name, usb_strerror());		}#endif	}	if (rval != 0)		report(RPT_WARNING, "%s/glcd2usb: could not claim interface", drvthis->name);	/*	 * Continue anyway, even if we could not claim the interface. Control	 * transfers should still work.	 */	ctd->device = handle;	/* Query device */	memset(&(ctd->tx_buffer), 0, sizeof(ctd->tx_buffer));	len = sizeof(display_info_t);//.........这里部分代码省略.........