libusb的异步也有这样的问题

1. 最近一直在关注异步机制，不管是网络库asio，libuv，还是libusb库，其实异步机制都是差不多的，都是基于回调函数、系统轮询实现的。

2. 下面是对一款USB产品做得测试结果，Windows环境下，用libusb异步API写的程序：



说明：用 Bus Hound 抓包，查看返回数值发现上面三个命令只有R是成功的（即有返回值），却对应在了B命令上，导致调用了B的回调。这就是异步容易导致的问题，也就是如果不停地发送命令，其中有一条命令失败，而这条命令的超时未过，回来的结果如果没有别的区分，会认为是该条命令的返回数据，而导致调用失败指令的回调函数，而导致比较严重的后果。

#include <errno.h>
#include <pthread.h>
#include <semaphore.h>
#include <signal.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include "libusb.h"

#define EP_IN           (6 | LIBUSB_ENDPOINT_IN)
#define EP_OUT		(2 | LIBUSB_ENDPOINT_OUT)

typedef enum {
SAVE_IMAGE      = 0x55,
UPLOAD_IMAGE    = 0xAA
}BULK_REQCODE;

typedef enum {
SAVE_IMAGE_VAL  = 0x00,
UPLOAD_B_VAL    = 0x00,
UPLOAD_G_VAL    = 0x01,
UPLOAD_R_VAL    = 0x02
}BULK_VALUE;

static struct libusb_device_handle *devh = NULL;
static unsigned char imgbuf_save[8];
static unsigned char imgbuf_upload[8];
static unsigned char imgbuf_R[2048*240];
static unsigned char imgbuf_G[2048*240];
static unsigned char imgbuf_B[2048*240];
static struct libusb_transfer *img_save = NULL;
static struct libusb_transfer *img_R = NULL;
static struct libusb_transfer *img_G = NULL;
static struct libusb_transfer *img_B = NULL;
static struct libusb_transfer *img_R_upload = NULL;
static struct libusb_transfer *img_G_upload = NULL;
static struct libusb_transfer *img_B_upload = NULL;
static int img_idx = 0;
static volatile sig_atomic_t do_exit = 0;
static int ii=0;

static pthread_t poll_thread;
static sem_t exit_sem;

static void request_exit(sig_atomic_t code)
{
do_exit = code;
sem_post(&exit_sem);
}

static void *poll_thread_main(void *arg)    //轮询是否main——thread结束
{
int r = 0;
printf("poll thread running\n");

while (!do_exit) {
struct timeval tv = { 1, 0 };
r = libusb_handle_events_timeout(NULL, &tv);    //处理任何待以处理的事件
if (r < 0) {
request_exit(2);
break;
}
}

printf("poll thread shutting down\n");
return NULL;
}

static int find_dpfp_device(void)
{
devh = libusb_open_device_with_vid_pid(NULL, 0x04b4, 0x8623);
return devh ? 0 : -EIO;
}

static void LIBUSB_CALL cb_img(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "upload_img_R_over callback : " << transfer->status << std::endl;
}

static void LIBUSB_CALL save_img(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "save Image callback : " << transfer->status << std::endl;
}

static void LIBUSB_CALL upload_img_B(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "upload_img_B callback : " << transfer->status << std::endl;
}

static void LIBUSB_CALL upload_img_B_over(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "upload_img_B_over callback : " << transfer->status << std::endl;
}

static void LIBUSB_CALL upload_img_G(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "upload_img_G callback : " << transfer->status << std::endl;
}

static void LIBUSB_CALL upload_img_G_over(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "upload_img_G_over callback : " << transfer->status << std::endl;
}

static void LIBUSB_CALL upload_img_R(struct libusb_transfer *transfer)
{
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
fprintf(stderr, "img transfer status %d?\n", transfer->status);
request_exit(2);
return;
}

std::cout << "upload_img_R callback : " << transfer->status << std::endl;

}

//由于该设备处理多命令异步发送过来的时候，只处理最后一条
static int LIBUSB_CALL submit_trans()
{
int r=0;

r = libusb_submit_transfer(img_save);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_save);   //异步取消之前提交传输
printf("1");
}

r = libusb_submit_transfer(img_B_upload);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_B_upload);   //异步取消之前提交传输
printf("1");
}

r = libusb_submit_transfer(img_B);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_B);   //异步取消之前提交传输
printf("1");
}

r = libusb_submit_transfer(img_G_upload);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_G_upload);   //异步取消之前提交传输
printf("1");
}

r = libusb_submit_transfer(img_G);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_G);   //异步取消之前提交传输
printf("1");
}

r = libusb_submit_transfer(img_R_upload);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_R_upload);   //异步取消之前提交传输
printf("1");
}

r = libusb_submit_transfer(img_R);   //提交一个传输并立即返回
if (r < 0) {
libusb_cancel_transfer(img_R);   //异步取消之前提交传输
printf("1");
}

return r;
}

static int alloc_transfers(void)
{
img_save = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_save)
return -ENOMEM;
img_R = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_R)
return -ENOMEM;
img_R_upload = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_R_upload)
return -ENOMEM;
img_G = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_G)
return -ENOMEM;
img_G_upload = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_G_upload)
return -ENOMEM;
img_B = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_B)
return -ENOMEM;
img_B_upload = libusb_alloc_transfer(0);    //0参数表明配置一个异步传输
if (!img_B_upload)
return -ENOMEM;

imgbuf_save[0] = (u_char)(SAVE_IMAGE);
imgbuf_save[1] = 0x00;
imgbuf_save[2] = 0x00;
imgbuf_save[3] = 0x00;
imgbuf_save[4] = (uchar)((0xff00 & 0x00f0)>>8);
imgbuf_save[5] = (uchar)(0x00ff & 0x00f0);
imgbuf_save[6] = 0x00;
imgbuf_save[7] = (u_char)(SAVE_IMAGE_VAL);
libusb_fill_bulk_transfer(img_save, devh, EP_OUT, imgbuf_save,
sizeof(imgbuf_save), save_img, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段

imgbuf_upload[0] = (u_char)UPLOAD_IMAGE;
imgbuf_upload[1] = 0x00;
imgbuf_upload[2] = 0x00;
imgbuf_upload[3] = 0x00;
imgbuf_upload[4] = (uchar)((0xff00 & 0x00f0)>>8);
imgbuf_upload[5] = (uchar)(0x00ff & 0x00f0);
imgbuf_upload[6] = 0x00;
imgbuf_upload[7] = (u_char)UPLOAD_B_VAL;
libusb_fill_bulk_transfer(img_B_upload, devh, EP_OUT, imgbuf_upload,
sizeof(imgbuf_upload), upload_img_B, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
libusb_fill_bulk_transfer(img_B, devh, EP_IN, imgbuf_B,
sizeof(imgbuf_B), upload_img_B_over, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段

imgbuf_upload[0] = (u_char)UPLOAD_IMAGE;
imgbuf_upload[1] = 0x00;
imgbuf_upload[2] = 0x00;
imgbuf_upload[3] = 0x00;
imgbuf_upload[4] = (uchar)((0xff00 & 0x00f0)>>8);
imgbuf_upload[5] = (uchar)(0x00ff & 0x00f0);
imgbuf_upload[6] = 0x00;
imgbuf_upload[7] = (u_char)UPLOAD_G_VAL;
libusb_fill_bulk_transfer(img_G_upload, devh, EP_OUT, imgbuf_upload,
sizeof(imgbuf_upload), upload_img_G, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
libusb_fill_bulk_transfer(img_G, devh, EP_IN, imgbuf_G,
sizeof(imgbuf_G), upload_img_G_over, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段

imgbuf_upload[0] = (u_char)UPLOAD_IMAGE;
imgbuf_upload[1] = 0x00;
imgbuf_upload[2] = 0x00;
imgbuf_upload[3] = 0x00;
imgbuf_upload[4] = (uchar)((0xff00 & 0x00f0)>>8);
imgbuf_upload[5] = (uchar)(0x00ff & 0x00f0);
imgbuf_upload[6] = 0x00;
imgbuf_upload[7] = (u_char)UPLOAD_R_VAL;
libusb_fill_bulk_transfer(img_R_upload, devh, EP_OUT, imgbuf_upload,
sizeof(imgbuf_upload), upload_img_R, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段
libusb_fill_bulk_transfer(img_R, devh, EP_IN, imgbuf_R,
sizeof(imgbuf_R), cb_img, NULL, 5000);   //该辅助函数来填充所需的libusb_transfer批量传输字段

return 0;
}

int main(void)
{
libusb_init(NULL);  //初始libusb库

int r = find_dpfp_device();
if(r!=0)
{
printf("%s\n", "not found dev" );
return 0;
}

r = libusb_claim_interface(devh, 0);    //声明设备接口
if (r < 0) {
fprintf(stderr, "usb_claim_interface error %d %s\n", r, strerror(-r));
goto out;
}
std::cout << "claimed interface" << std::endl;

r = pthread_create(&poll_thread, NULL, poll_thread_main, NULL); //子线程poll_thread_main用来处理USB事件
if (r)
goto out;

r = alloc_transfers();  //配置一个异步bulk传输和一个中断传输，先alloc然后fill_XX_transfer
if (r < 0) {
request_exit(1);
pthread_join(poll_thread, NULL);    //函数pthread_join用来等待一个线程的结束
goto out;
}

r = submit_trans(); //submit一个传输
if (r < 0) {
request_exit(1);
pthread_join(poll_thread, NULL);    //失败等待线程结束
goto out;
}

while (!do_exit)
sem_wait(&exit_sem);    //等待退出信号量

printf("shutting down...\n");
pthread_join(poll_thread, NULL);

out_release:
libusb_release_interface(devh, 0);
out:
libusb_close(devh);
libusb_exit(NULL);
sem_destroy(&exit_sem);
return r >= 0 ? r : -r;
}