(libusb) usb口自动刷新(2)，2024最新阿里网络安全高级面试题及答案

最新推荐文章于 2024-04-17 00:09:23 发布

面试狗哦

最新推荐文章于 2024-04-17 00:09:23 发布

阅读量339

点赞数 5

分类专栏： 2024年程序员学习文章标签： web安全命令模式安全

本文链接：https://blog.csdn.net/m0_60452134/article/details/137459407

版权

2024年程序员学习专栏收录该内容

322 篇文章 1 订阅

订阅专栏

Register_arrived();
Register_left();
}
}

/**
* @brief Hotplug::~Hotplug
* 析构的时候注销和释放句柄
*/
Hotplug::~Hotplug() {
libusb_hotplug_deregister_callback(context, usb_arrived_handle);
libusb_hotplug_deregister_callback(context, usb_left_handle);
libusb_exit(context);
}

/**
* @brief Hotplug::Register_arrived
* @return
* 注册热拔插arrive
*/
int Hotplug::Register_arrived() {
int res = libusb_hotplug_register_callback(
context, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, LIBUSB_HOTPLUG_NO_FLAGS,
m_regiest_vendor, m_regiest_product, m_regiest_deviceClass,
Hotplug::usb_arrived_callback, NULL, &usb_arrived_handle);
return res;
}

/**
* @brief Hotplug::Register_left
* @return
* 注册热拔插left
*/
int Hotplug::Register_left() {
int res = libusb_hotplug_register_callback(
context, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_NO_FLAGS,
m_regiest_vendor, m_regiest_product, m_regiest_deviceClass,
Hotplug::usb_left_callback, NULL, &usb_left_handle);
return res;
}
} // namespace USB

`code`包

WIDGET_Main.h

#ifndef FORM_H_27453073957
#define FORM_H_27453073957

#include
#include
#include

#include “THREAD_TimerUsb.h”

namespace Ui {
class MainWidget;
}

class MainWidget : public QWidget {
Q_OBJECT

private:
QScopedPointerUi::MainWidget ui;

private:
TimerUsb m_usb;

public:
explicit MainWidget(QWidget *parent = nullptr);
~MainWidget();

private:
void show_usbDeviceMsgAll();
void start_work();
};

#endif // FORM_H_27453073957

WIDGET_Main.cpp

#include “WIDGET_Main.h”

#include
#include
#include
#include

#include “ui_WIDGET_Main.h”
#include “usb/USB_Reset.h”

QWidget *g_widgetDisplayBoard = nullptr;
QtMessageHandler g_oldMessageHandler = nullptr;
QMutex g_dispalyMutex;

/**
* debug 重定向
*/
void newDebugHandlerFunc(QtMsgType type, const QMessageLogContext &context, const QString &msg) {
QMutexLocker locker(&g_dispalyMutex);
if (g_widgetDisplayBoard) {
dynamic_cast<QTextEdit *>(g_widgetDisplayBoard)->append(msg);
} else {
g_oldMessageHandler(type, context, msg);
}
}

/**
* @brief MainWidget::MainWidget
* @param parent
* 1. debug重定向
* 2. connect
*/
MainWidget::MainWidget(QWidget *parent) : QWidget(parent), ui(new Ui::MainWidget{}) {
ui->setupUi(this);
setWindowTitle(“usb controller”);

/// debug -> widget
{
g_widgetDisplayBoard = ui->textEdit;
g_oldMessageHandler = qInstallMessageHandler(newDebugHandlerFunc);
}

/// connect
{
connect(ui->btn_showAll, &QPushButton::clicked, this,
&MainWidget::show_usbDeviceMsgAll);
connect(ui->btn_clear, &QPushButton::clicked, ui->textEdit,
&QTextEdit::clear);
connect(ui->btn_start, &QPushButton::clicked, this,
&MainWidget::start_work);

connect(&m_usb, &TimerUsb::signal_message, this,
[](const QString &msg) { qInfo() << msg; });
}

/// before exe
{ show_usbDeviceMsgAll(); }
}

/**
* @brief MainWidget::~MainWidget
* 将线程安全关闭
*/
MainWidget::~MainWidget() {
if (m_usb.isRunning()) {
m_usb.quit();
m_usb.wait();
}
}

/**
* @brief MainWidget::show_usbDeviceMsgAll
* 展示所有usb设备的信息
* 因为设计的是通用库
* 因此返回的是std::vectorstd::string
*/
void MainWidget::show_usbDeviceMsgAll() {
for (auto &&s : USB::Reset().Show_device()) {
qDebug() << s.c_str();
}
}

/**
* @brief MainWidget::start_work
* 检测线程启动
*/
void MainWidget::start_work() {
uint vendor = ui->edit_Vendor->text().toUInt();
double time = ui->edit_timeout->text().toDouble();
m_usb.Set_usbDeviceVendor(vendor);
m_usb.Set_timerInterval(time * 1000);
m_usb.Set_timerStart();

if (false == m_usb.isRunning()) {
qDebug() << “=== start before =";
m_usb.start();
qDebug() << "= start after ===”;
}
}

WIDGET_Main.ui

<?xml version="1.0" encoding="UTF-8"?> MainWidget 0 0 726 480 UsbForm 12 8746 12 目标Vendor 12 倒计时（秒） 12 2 18 设备usb列表 18 清空列表 18 开始

THREAD_TimerUsb.h

#ifndef THREADUSB_H_70403004403
#define THREADUSB_H_70403004403

#include
#include

class TimerUsb : public QThread {
Q_OBJECT
private:
uint32_t m_usbDeviceVendor = 0;

private:
QTimer m_timer;
int m_timerIntervalMsec = 1500;

public:
TimerUsb();

public:
void Set_usbDeviceVendor(uint32_t vendor);

public:
void Set_timerInterval(int msec = 1500);
void Set_timerStart();
void Set_timerStop();
bool Is_timerRunning();

protected:
void run() override;

signals:
void signal_message(const QString&);
};

#endif // THREADUSB_H_70403004403

THREAD_TimerUsb.cpp

#include “THREAD_TimerUsb.h”

#include
#include

#include “usb/USB_Reset.h”

#if 0
#define DEBUG_MODEL qInfo() <<
#else
#define DEBUG_MODEL emit this->signal_message
#endif

/**
* @brief ThreadUsb::ThreadUsb
* construct
*/
TimerUsb::TimerUsb() {
Set_timerInterval();
}

/**
* @brief ThreadUsb::Set_usbDeviceVendor
* @param vendor
* 根据 vendor 查询设备
*/
void TimerUsb::Set_usbDeviceVendor(uint32_t vendor) {
this->m_usbDeviceVendor = vendor;
}

/**
* @brief ThreadUsb::Set_timerInterval
* @param msec
* 设置reset间隔
*/
void TimerUsb::Set_timerInterval(int msec) {
this->m_timerIntervalMsec = msec;
m_timer.setInterval(m_timerIntervalMsec);
}

/**
* @brief TimerUsb::Set_timerStart
* 启动定时器，但不启动线程
*/
void TimerUsb::Set_timerStart() {
this->m_timer.start();
}

/**
* @brief TimerUsb::Set_timerStop
* 关闭定时器，但不关闭线程
*/
void TimerUsb::Set_timerStop() {
this->m_timer.stop();
}

/**
* @brief TimerUsb::Is_timerRunning
* @return
* 定时器是否运行
*/
bool TimerUsb::Is_timerRunning() {
return this->m_timer.isActive();
}

/**
* @brief ThreadUsb::run
* 定时器timeout一次，usb-reset一次
*/
void TimerUsb::run() {
USB::Reset usb;
libusb_device* device = nullptr;

/// 为了防止刚启动的时候没有获得
/// 高强度轮询获取
const size_t loopDeviceCount = 1e5 + 10;
const size_t loopContextPeriod = 1e3;
for (size_t i = 0; i < loopDeviceCount; i += 1) {
device = usb.Find_deviceByidVendor(this->m_usbDeviceVendor);
if (nullptr != device) {
break;
} else {
if (i % loopContextPeriod == 0) {
DEBUG_MODEL(“device is null & context resert”);
USB::Reset::Reset_context();
}
}
}
if (nullptr == device) {
DEBUG_MODEL(“libusb_device is null & Thread end!”);
return;
} else {
DEBUG_MODEL(“libusb_device require ok!”);
}

libusb_device_handle* handle = usb.Get_handleByOpenDevice(device);
if (handle == nullptr) {
DEBUG_MODEL(“libusb_device require is null & Thread end!”);
return ;
} else {
DEBUG_MODEL(“libusb_device_handle require ok!”);
}

auto con = connect(&this->m_timer, &QTimer::timeout, & {
int res = usb.Reset_usbByHandle(handle);
if (LIBUSB_SUCCESS == res) {
DEBUG_MODEL(“reset Success”);
} else {
DEBUG_MODEL("reset Error; errorType = " + QString::number(res));
}
/// 句柄不归还，持续重置
// usb.Close_deviceByHandle(handle);
});

/// 开启事件循环
exec();
this->m_timer.stop();
disconnect(con);
}