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

void lamp_shutdown(){  int ret = usb_release_interface(launcher, 0);  printf("Released interface 0: %d/n", ret);  ret = usb_release_interface(launcher, 1);  printf("Released interface 1: %d/n", ret);  usb_close(launcher);}

int main(void){	struct usb_device *dev;	usb_dev_handle *handle;	uint16_t iface;	int state;	uint32_t offset;	banner();	usb_init();retry:	if(!(dev = find_dev()) || !(handle = get_dfu_interface(dev, &iface))) {		puts("FATAL: No compatible device found!/n");#ifdef WIN32		system("pause");#endif		return -1;	}	state = dfu_getstate(handle, iface);	if((state < 0) || (state == STATE_APP_IDLE)) {		puts("Resetting device in firmware upgrade mode...");		dfu_detach(handle, iface, 1000);		usb_release_interface(handle, iface);		usb_close(handle);#ifdef WIN32		Sleep(5000);#else		sleep(5);#endif		goto retry;	}	printf("Found device at %s:%s/n", dev->bus->dirname, dev->filename);	dfu_makeidle(handle, iface);	for(offset = 0; offset < bindatalen; offset += 1024) {		printf("Progress: %d%%/r", (offset*100)/bindatalen);		fflush(stdout);		assert(stm32_mem_erase(handle, iface, LOAD_ADDRESS + offset) == 0);		stm32_mem_write(handle, iface, (void*)&bindata[offset], 1024);	}	stm32_mem_manifest(handle, iface);	usb_release_interface(handle, iface);	usb_close(handle);	puts("All operations complete!/n");#ifdef WIN32		system("pause");#endif	return 0;}

/* * Function usbobex_connect_request (self) * *    Open the USB connection * */int usbobex_connect_request(obex_t *self){	int ret;#ifndef _WIN32	DEBUG(4, "/n");	self->trans.self.usb.dev_control = usb_open(self->trans.self.usb.device);	self->trans.self.usb.dev_data = usb_open(self->trans.self.usb.device);	ret = usb_set_configuration(self->trans.self.usb.dev_control, self->trans.self.usb.configuration);	if (ret < 0) {		DEBUG(4, "Can't set configuration %d", ret);	}	ret = usb_claim_interface(self->trans.self.usb.dev_control, self->trans.self.usb.control_interface);	if (ret < 0) {		DEBUG(4, "Can't claim control interface %d", ret);		goto err1;	}	ret = usb_set_altinterface(self->trans.self.usb.dev_control, self->trans.self.usb.control_setting);	if (ret < 0) {		DEBUG(4, "Can't set control setting %d", ret);		goto err2;	}	ret = usb_claim_interface(self->trans.self.usb.dev_data, self->trans.self.usb.data_interface);	if (ret < 0) {		DEBUG(4, "Can't claim data interface %d", ret);		goto err2;	}	ret = usb_set_altinterface(self->trans.self.usb.dev_data, self->trans.self.usb.data_active_setting);	if (ret < 0) {		DEBUG(4, "Can't set data active setting %d", ret);		goto err3;	}	self->trans.mtu = OBEX_MAXIMUM_MTU;	DEBUG(2, "transport mtu=%d/n", self->trans.mtu);	return 1;err3:	usb_release_interface(self->trans.self.usb.dev_data, self->trans.self.usb.data_interface);	err2:	usb_release_interface(self->trans.self.usb.dev_control, self->trans.self.usb.control_interface);err1:	usb_close(self->trans.self.usb.dev_data);	usb_close(self->trans.self.usb.dev_control);	return ret;#endif /* _WIN32 */}

int k8061_ExecIO( int iCard, int nSend, int nReceive ) {  int n_write = 0, n_read = 0;  if ( iCard < 0 || iCard > 7 ) {    fprintf( stderr, "*** error <k8061_ExecIO> : Card number out of range %d.../n", iCard );    fflush( stderr );    return -1;  }  if ( _k8061_IsOpen[iCard] ) {    n_write = usb_bulk_write( _k8061_Handle[iCard] ,k8061_epWrite, _k8061_WriteBuffer, 			      nSend, k8061_ioTimeOut );    usleep( k8061_ioWait );    if ( n_write < 0 ) {      fprintf( stderr, "*** %s/n", usb_strerror() );      fprintf( stderr, "*** error <k8061_ExecIO> : Error writing command to card %d/n", iCard );      fflush( stderr );      if ( _k8061_Handle[iCard] ) usb_release_interface( _k8061_Handle[iCard], k8061_iClaim );      if ( _k8061_Handle[iCard] ) usb_close( _k8061_Handle[iCard] );      _k8061_IsOpen[iCard] = 0;            return -1;    }         n_read = usb_bulk_read( _k8061_Handle[iCard] ,k8061_epRead, _k8061_ReadBuffer, 			    nReceive, k8061_ioTimeOut );    usleep( k8061_ioWait );    if ( n_read < 0 ) {      fprintf( stderr, "*** %s/n", usb_strerror() );      fprintf( stderr, "*** error <k8061_ExecIO> : Error reading buffer from card %d/n", iCard );      fflush( stderr );      if ( _k8061_Handle[iCard] ) usb_release_interface( _k8061_Handle[iCard], k8061_iClaim );      if ( _k8061_Handle[iCard] ) usb_close( _k8061_Handle[iCard] );      _k8061_IsOpen[iCard] = 0;      return -1;    }   } else {    fprintf( stderr, "*** error <k8061_ExecIO> : Card %d not found/not opened.../n", iCard );    fflush( stderr );    return -1;  }      return 0;}

static int drv_TF_close(void){    usb_release_interface(lcd, interface);    usb_close(lcd);    return 0;}

int main(int argc, char * argv[]){	struct pwcmech * pwcmech;	pwcmech->dev = ifinit_pwcblock();	pwcmech->com = ifinit_usbcom();	ifbind_pwcblock(pwcmech->dev, pwcmech->com);	//use driver	usb_init(pwcmech->com);	if ( usb_open(pwcmech->com) )	{		finish(pwcmech);		return 0;	}	//should work seamlessly	usb_if_claim(pwcmech->com, pwcmech->com->standard_descriptors.highspeed.cameraStream.cameraStreamConf);	setVideoMode(pwcmech, 9);	setLeds(pwcmech, 10,5);	usb_release_interface(pwcmech->com, pwcmech->com->standard_descriptors.highspeed.cameraStream.cameraStreamConf);	usb_close(pwcmech->com);	finish(pwcmech);	return 0;}

int main( int argc, char **argv){	usb_dev_handle *lvr_winusb;	if ((lvr_winusb = setup_libusb_access()) == NULL) 	{		exit(-1);	} 	//printf("Testing control transfer: ");	//test_control_transfer(lvr_winusb);	//printf("Testing interrupt transfer: ");	//test_interrupt_transfer(lvr_winusb);	//printf("Testing bulk transfer: "); 	//test_bulk_transfer(lvr_winusb);	usb_release_interface(lvr_winusb, 0);	usb_reset(lvr_winusb);	usb_close(lvr_winusb);	return 0;}

void hidasp_close(void){	if(	usb_dev ) {		usb_release_interface(usb_dev, 0);		usb_close(usb_dev);	}}

int main(void) {    usb_dev_handle *dev = NULL; /* the device handle */    uint8_t readBuffer[0x200*0x100];    /* Set up USB */    usb_init();    usb_find_busses();    usb_find_devices();    if (!(dev = open_dev())) {        perror("device not found!/n");		exit(EXIT_FAILURE);    }/*    if (usb_set_configuration(dev, 1) < 0) {        perror("setting config 1 failed/n");        usb_close(dev);        exit(EXIT_FAILURE);    }*/    if (usb_claim_interface(dev, 0) < 0)    {        perror("claiming interface failed/n");        usb_close(dev);        exit(EXIT_FAILURE);    }    //FIXME: sniffed    read10(readBuffer,0x100,0x0,dev);    printReadBuffer(readBuffer);    /* Clean up */    usb_release_interface(dev, 0);    usb_close(dev);    exit(0);}

int _ykusb_read(void *dev, int report_type, int report_number,		char *buffer, int size){	int rc = usb_claim_interface((usb_dev_handle *)dev, 0);	if (rc >= 0) {		int rc2;		rc = usb_control_msg((usb_dev_handle *)dev,				     USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_ENDPOINT_IN,				     HID_GET_REPORT,				     report_type << 8 | report_number, 0,				     buffer, size,				     1000);		/* preserve a control message error over an interface		   release one */		rc2 = usb_release_interface((usb_dev_handle *)dev, 0);		if (rc >= 0 && rc2 < 0)			rc = rc2;	}	if (rc >= 0)		return rc;	if(rc == 0)		yk_errno = YK_ENODATA;	else		yk_errno = YK_EUSBERR;	return 0;}

/* void test_control_transfer(usb_dev_handle *dev) {//   usb_set_altinterface(dev, 0);   usb_release_interface(dev, 0); }*/ void test_interrupt_transfer(usb_dev_handle *dev) {   int r,i;   char answer[reqIntLen];   char question[reqIntLen];   for (i=0;i<reqIntLen; i++) question[i]=i;   r = usb_interrupt_write(dev, endpoint_Int_out, question, reqIntLen, timeout);   if( r < 0 )   {	  perror("USB interrupt write"); bad("USB write failed");    }   r = usb_interrupt_read(dev, endpoint_Int_in, answer, reqIntLen, timeout);   if( r != reqIntLen )   {	  perror("USB interrupt read"); bad("USB read failed");    }//   for (i=0;i<reqIntLen; i++) printf("%i, %i, /n",question[i],answer[i]);	for(i = 0;i < reqIntLen; i++) {		if(i%8 == 0)			printf("/n");		printf("%02x, %02x; ",question[i],answer[i]);	}	printf("/n");//   usb_set_altinterface(dev, 0);   usb_release_interface(dev, 0); }

int xusb_close(struct xusb *xusb){	if(xusb) {		if(xusb->handle) {			assert(xusb->spec);			assert(xusb->spec->name);			DBG("Closing interface /"%s/"/n", xusb->spec->name);			if(xusb->is_claimed) {				if(usb_release_interface(xusb->handle, xusb->spec->my_interface_num) != 0) {					ERR("Releasing interface: usb: %s/n", usb_strerror());				}				xusb->is_claimed = 0;			}			if(xusb->is_open) {				if(usb_close(xusb->handle) != 0) {					ERR("Closing device: usb: %s/n", usb_strerror());				}				xusb->is_open = 0;			}			xusb->handle = NULL;		}		xusb = NULL;	}	return 0;}

/** * Close the driver (do necessary clean-up). * /param drvthis  Pointer to driver structure. */MODULE_EXPORT voidIOWarrior_close(Driver *drvthis){  PrivateData *p = drvthis->private_data;  if (p != NULL) {    /* don't turn display off: keep the logoff message */    // iowlcd_display_on_off(p,0,0,0);    /* IOW leave LCD mode */    iowlcd_disable(p);    /* release interface 1 */    usb_release_interface(p->udh, 1);    /* close USB */    usb_close(p->udh);    if (p->framebuf != NULL)      free(p->framebuf);    p->framebuf = NULL;    if (p->backingstore != NULL)      free(p->backingstore);    p->backingstore = NULL;    free(p);  }  drvthis->store_private_ptr(drvthis, NULL);  debug(RPT_DEBUG, "%s: closed", drvthis->name);}

//---------------------------------------------------------------------------// Attempt to acquire a 1-Wire net//// 'portnum'    - number 0 to MAX_PORTNUM-1.  This number is provided to//                indicate the symbolic port number.// 'port_zstr'  - zero terminated port name.  // 'return_msg' - zero terminated return message. //// Returns: TRUE - success, port opened//SMALLINT owAcquireUSB(int portnum, char *port_zstr, char *return_msg){	if (!initted_flag)		usb_ds2490_init();		/* check the port string */	if (strcmp (port_zstr, "USB")) {		strcpy(return_msg, "owAcquire called with invalid port string/n");	      	return 0;	}		/* check to see if the portnumber is valid */	if (usb_num_devices < portnum) {		strcpy(return_msg, "Attempted to select invalid port number/n");		return FALSE;	}	/* check to see if opening the device is valid */	if (usb_dev_handle_list[portnum] != NULL) {		strcpy(return_msg, "Device allready open/n");		return FALSE;	}	/* open the device */	usb_dev_handle_list[portnum] = usb_open(usb_dev_list[portnum]);	if (usb_dev_handle_list[portnum] == NULL) {		strcpy(return_msg, "Failed to open usb device/n");		printf("%s/n", usb_strerror());		return FALSE;	}	/* set the configuration */	if (usb_set_configuration(usb_dev_handle_list[portnum], 1)) {		strcpy(return_msg, "Failed to set configuration/n");		printf("%s/n", usb_strerror());		usb_close(usb_dev_handle_list[portnum]);		return FALSE;	}	/* claim the interface */	if (usb_claim_interface(usb_dev_handle_list[portnum], 0)) {		strcpy(return_msg, "Failed to claim interface/n");		printf("%s/n", usb_strerror());		usb_close(usb_dev_handle_list[portnum]);		return FALSE;	}	/* set the alt interface */	if (usb_set_altinterface(usb_dev_handle_list[portnum], 3)) {		strcpy(return_msg, "Failed to set altinterface/n");		printf("%s/n", usb_strerror());		usb_release_interface(usb_dev_handle_list[portnum], 0);		usb_close(usb_dev_handle_list[portnum]);		return FALSE;	}	/* we're all set here! */	strcpy(return_msg, "DS2490 successfully acquired by USB driver/n");	return TRUE;}

static int pickit2_shutdown(void *data){	/* Set all pins to float and turn voltages off */	uint8_t command[CMD_LENGTH] = {		CMD_EXEC_SCRIPT,		8,		SCR_SET_PINS,		3, /* Bit-0=1(PDC In), Bit-1=1(PGD In), Bit-2=0(PDC LL), Bit-3=0(PGD LL) */		SCR_SET_AUX,		1, /* Bit-0=1(Aux In), Bit-1=0(Aux LL) */		SCR_MCLR_GND_OFF,		SCR_VPP_OFF,		SCR_VDD_OFF,		SCR_BUSY_LED_OFF,		CMD_END_OF_BUFFER	};	int ret = usb_interrupt_write(pickit2_handle, ENDPOINT_OUT, (char *)command, CMD_LENGTH, DFLT_TIMEOUT);	if (ret != CMD_LENGTH) {		msg_perr("Command Shutdown failed (%s)!/n", usb_strerror());		ret = 1;	}	if (usb_release_interface(pickit2_handle, 0) != 0) {		msg_perr("Could not release USB interface!/n");		ret = 1;	}	if (usb_close(pickit2_handle) != 0) {		msg_perr("Could not close USB device!/n");		ret = 1;	}	return ret;}

void teensy_close(void){	if (!libusb_teensy_handle) return;	usb_release_interface(libusb_teensy_handle, 0);	usb_close(libusb_teensy_handle);	libusb_teensy_handle = NULL;}

//---------------------------------------------------------------------------// Release the previously acquired a 1-Wire net.//// 'portnum'    - number 0 to MAX_PORTNUM-1.  This number is provided to//                indicate the symbolic port number.// 'return_msg' - zero terminated return message. //void owReleaseUSB(int portnum, char *return_msg){	usb_release_interface(usb_dev_handle_list[portnum], 0);	usb_close(usb_dev_handle_list[portnum]);	usb_dev_handle_list[portnum] = NULL;	strcpy(return_msg, "DS2490 successfully released by USB driver/n");}

//----------------------------------------------------------------------//check lockdown verifier button statusint ldn_verifier_checkbuttonstatus(void){	struct usb_dev_handle *hdl;	int status=-1;	int verifier_was_unplugged=0;		do{		while( (hdl = ldn_find_verifier()) == NULL){			verifier_was_unplugged=1;			Sleep(100);	//discover our verifier		}				if(verifier_was_unplugged){			verifier_was_unplugged=0;						if(ldn_trusted_environment)				usbdevice_setdevicestate(hdl, GREEN_LED); 			else				usbdevice_setdevicestate(hdl, RED_LED); 		}				status = usbdevice_checkbuttonstatus(hdl);					usb_release_interface(hdl, 0);		usb_close(hdl);			}while(status < 0);		return status;}

void PeperoniDevice::close(quint32 line, OperatingMode mode){    m_operatingModes[line] &= ~mode;    if (mode == InputMode && m_running == true)    {        m_running = false;        wait();    }    if (m_operatingModes[line] != CloseMode)        return;    if (m_device != NULL && m_handle != NULL)    {        /* Release the interface in case we claimed it */        int r = usb_release_interface(m_handle, PEPERONI_IFACE_EP0);        if (r < 0)        {            qWarning() << "PeperoniDevice" << name(m_baseLine)                       << "is unable to release interface EP0!";        }        usb_close(m_handle);    }    m_handle = NULL;}

grub_usb_err_tgrub_usb_bulk_write (grub_usb_device_t dev,		     int endpoint, grub_size_t size, char *data){  usb_dev_handle *devh;  struct usb_device *d = dev->data;  devh = usb_open (d);  if (usb_claim_interface (devh, 0) < 0)    goto fail;  if (usb_bulk_write (devh, endpoint, data, size, 20) < 0)    goto fail;  if (usb_release_interface (devh, 0) < 0)    goto fail;  usb_close (devh);  return GRUB_USB_ERR_NONE; fail:  usb_close (devh);  return GRUB_USB_ERR_STALL;}

/***************************************************************************** * *					CloseUSB * ****************************************************************************/status_t CloseUSB(unsigned int reader_index){	/* device not opened */	if (usbDevice[reader_index].handle == NULL)		return STATUS_UNSUCCESSFUL;	DEBUG_COMM3("Closing USB device: %s/%s",		usbDevice[reader_index].dirname,		usbDevice[reader_index].filename);	if (usbDevice[reader_index].ccid.arrayOfSupportedDataRates		&& (usbDevice[reader_index].ccid.bCurrentSlotIndex == 0))	{		free(usbDevice[reader_index].ccid.arrayOfSupportedDataRates);		usbDevice[reader_index].ccid.arrayOfSupportedDataRates = NULL;	}	/* one slot closed */	(*usbDevice[reader_index].nb_opened_slots)--;	/* release the allocated ressources for the last slot only */	if (0 == *usbDevice[reader_index].nb_opened_slots)	{		DEBUG_COMM("Last slot closed. Release resources");		/* reset so that bSeq starts at 0 again */		if (DriverOptions & DRIVER_OPTION_RESET_ON_CLOSE)			(void)usb_reset(usbDevice[reader_index].handle);		(void)usb_release_interface(usbDevice[reader_index].handle,			usbDevice[reader_index].interface);		(void)usb_close(usbDevice[reader_index].handle);#ifdef __APPLE__		DEBUG_INFO3("Terminating thread: %s/%s",			usbDevice[reader_index].dirname, usbDevice[reader_index].filename);		// Terminate thread		*usbDevice[reader_index].pTerminated = TRUE;		pthread_join(usbDevice[reader_index].hThread, NULL);		// Free bStatus lock		pthread_mutex_destroy(usbDevice[reader_index].ccid.pbStatusLock);#endif		// Free array of bStatus		free(usbDevice[reader_index].ccid.bStatus);		free(usbDevice[reader_index].dirname);		free(usbDevice[reader_index].filename);	}	/* mark the resource unused */	usbDevice[reader_index].handle = NULL;	usbDevice[reader_index].dirname = NULL;	usbDevice[reader_index].filename = NULL;	usbDevice[reader_index].interface = 0;	usbDevice[reader_index].ccid.bStatus = NULL;		// Array of bStatus	return STATUS_SUCCESS;} /* CloseUSB */

static void usbtr_destroy(transport_t tr_base){	struct rf2500_transport *tr = (struct rf2500_transport *)tr_base;	usb_release_interface(tr->handle, tr->int_number);	usb_close(tr->handle);	free(tr);}

HardwareThunder::~HardwareThunder(){    if (m_usbHandler)    {        usb_release_interface(m_usbHandler, 0);        usb_close(m_usbHandler);    }}

/** * Disconnect from current device */void M64BirDevice::disconnectDevice(){    usb_release_interface( mDeviceHandle, 0 );    if( mDeviceHandle != NULL )    {        usb_close( mDeviceHandle );    }}

void dpf_ax_close(DPFAXHANDLE h){    DPFContext *dpf = (DPFContext *) h;    usb_release_interface(dpf->udev, 0);    usb_close(dpf->udev);    free(dpf);}

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

void cleanup_USB_CTR( usb_dev_handle *udev ){  if (udev) {    usb_clear_halt(udev, USB_ENDPOINT_IN|6);    usb_release_interface(udev, 0);    usb_close(udev);  }}

void canon_close_camera(usb_dev_handle *camera_handle){  /* close connection to the camera */  fprintf(stderr, "Closing connection to camera... ");  usb_release_interface(camera_handle, 0);  usb_close(camera_handle);  fprintf(stderr, "done./n");}

static int drv_MOGX_close(void){    /* close whatever port you've opened */    usb_release_interface(lcd_dev, 0);    usb_close(lcd_dev);    return 0;}

void disconnectDevice() {    if ( Connection_Status == CONNECTED) {        //The following functiom releases a previously claimed interface        usb_release_interface(MyLibusbDeviceHandle, 0);        //closes a device opened        usb_close(MyLibusbDeviceHandle);    }}