(libusb) usb口自动刷新，【大牛系列教学

* @return
* 获取device
*/
libusb_device* Reset::Find_deviceByidVendor(uint32_t Vendor) {
/// ret
libusb_device* device = nullptr;

/// help data
libusb_device_handle* deviceHandle = nullptr;
libusb_device** deviceList = nullptr;

libusb_get_device_list(nullptr, &deviceList);
for (int i = 0; deviceList[i] != nullptr; i += 1) {
device = deviceList[i];
libusb_device_descriptor descriptor;
int ret = libusb_get_device_descriptor(device, &descriptor);
if (LIBUSB_SUCCESS != ret) {
continue;
}

if (descriptor.idVendor == Vendor) {
const int isOpen = libusb_open(device, &deviceHandle);
if (LIBUSB_SUCCESS == isOpen) {
libusb_close(deviceHandle);
break;
} else {
device = nullptr;
}
} else {
device = nullptr;
}
}

return device;
}

/**
* @brief UsbBase::Get_handleByOpenDevice
* @param device
* @return
* 根据传入的设备指针
* 通过open操作
* 获取句柄指针
*/
libusb_device_handle* Reset::Get_handleByOpenDevice(libusb_device* device) {
if (nullptr == device) {
return nullptr;
}
libusb_device_handle* deviceHandle = nullptr;
const int isOpen = libusb_open(device, &deviceHandle);
if (LIBUSB_SUCCESS == isOpen) {
return deviceHandle;
} else {
return nullptr;
}
}

/**
* @brief UsbBase::Reset_usbByHandle
* @param device_handle
* @return
* 通过句柄重置设备
* 为0则表示成功
*/
int Reset::Reset_usbByHandle(libusb_device_handle* device_handle) {
if (nullptr == device_handle) {
return EMPTY_POINTER_INT;
}
const int isReset = libusb_reset_device(device_handle);
//! TODO if (isReset ?= 0) => log
return isReset;
}

/**
* @brief UsbBase::Close_deviceByHandle
* @param device_handle
* 手动通过句柄指针关闭设备
*/
void Reset::Close_deviceByHandle(libusb_device_handle* device_handle) {
if (nullptr == device_handle) {
return;
}
libusb_close(device_handle);
}
} // namespace USB

USB_Hotplug.h

#ifndef HOTPLUG_H_27452998650
#define HOTPLUG_H_27452998650

extern “C” {
#include “libusb-1.0/libusb.h”
}

namespace USB {
class Hotplug final {
private:
static libusb_device_handle *m_deviceHandle;

private:
static int LIBUSB_CALL usb_arrived_callback(struct libusb_context *ctx,
struct libusb_device *dev,
libusb_hotplug_event event,
void *userdata);
static int LIBUSB_CALL usb_left_callback(struct libusb_context *ctx,
struct libusb_device *dev,
libusb_hotplug_event event,
void *userdata);

private:
char str[1024]{};

private:
libusb_hotplug_callback_handle usb_arrived_handle;
libusb_hotplug_callback_handle usb_left_handle;
libusb_context *context = nullptr;

private:
uint32_t m_regiest_vendor = LIBUSB_HOTPLUG_MATCH_ANY;
uint32_t m_regiest_product = LIBUSB_HOTPLUG_MATCH_ANY;
uint32_t m_regiest_deviceClass = LIBUSB_HOTPLUG_MATCH_ANY;

private:
Hotplug();

public:
Hotplug(uint32_t vendor, uint32_t product, uint32_t deviceClass);
~Hotplug();

public:
int Register_arrived();
int Register_left();
};
} // namespace USB

#endif // HOTPLUG_H_27452998650

USB_Hotplug.cpp

#include “USB_Hotplug.h”

#include

namespace USB {
/**
* @brief Hotplug::m_deviceHandle
* 主要用于静态的回调函数
*/
libusb_device_handle *Hotplug::m_deviceHandle = nullptr;

/**
* @brief Hotplug::usb_arrived_callback
* @param ctx
* @param dev
* @param event
* @param userdata
* @return
* 热拔插 arrive 的回调
*/
int Hotplug::usb_arrived_callback(libusb_context *ctx, libusb_device *dev,
libusb_hotplug_event event, void *userdata) {
struct libusb_device_handle *handle;
struct libusb_device_descriptor desc;
unsigned char buf[512];
int rc;

libusb_get_device_descriptor(dev, &desc);
printf(“Add usb device: \n”);
printf(“\tCLASS(0x%x) SUBCLASS(0x%x) PROTOCOL(0x%x)\n”, desc.bDeviceClass,
desc.bDeviceSubClass, desc.bDeviceProtocol);
printf(“\tVENDOR(0x%x) PRODUCT(0x%x)\n”, desc.idVendor, desc.idProduct);
rc = libusb_open(dev, &handle);
if (LIBUSB_SUCCESS != rc) {
printf(“Could not open USB device\n”);
return 0;
}

memset(buf, 0, sizeof(buf));
rc = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, buf,
sizeof(buf));
if (rc < 0) {
printf(“Get Manufacturer failed\n”);
} else {
printf(“\tManufacturer: %s\n”, buf);
}

memset(buf, 0, sizeof(buf));
rc = libusb_get_string_descriptor_ascii(handle, desc.iProduct, buf,
sizeof(buf));
if (rc < 0) {
printf(“Get Product failed\n”);
} else {
printf(“\tProduct: %s\n”, buf);
}

memset(buf, 0, sizeof(buf));
rc = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, buf,
sizeof(buf));
if (rc < 0) {
printf(“Get SerialNumber failed\n”);
} else {
printf(“\tSerialNumber: %s\n”, buf);
}
libusb_close(handle);

return 0;
}

/**
* @brief Hotplug::usb_left_callback
* @param ctx
* @param dev
* @param event
* @param userdata
* @return
* 热拔插left的回调
*/
int Hotplug::usb_left_callback(libusb_context *ctx, libusb_device *dev,
libusb_hotplug_event event, void *userdata) {
struct libusb_device_descriptor desc;
libusb_get_device_descriptor(dev, &desc);
const int isReset = libusb_reset_device(m_deviceHandle);
return isReset;
}

/**
* @brief Hotplug::Hotplug
* 构造的时候init
*/
Hotplug::Hotplug() {
libusb_init(&context);
}

/**
* @brief Hotplug::Hotplug
* @param vendor
* @param product
* 委托构造
*/
Hotplug::Hotplug(uint32_t vendor, uint32_t product, uint32_t deviceClass) : Hotplug() {
/// data
{
m_regiest_vendor = vendor;
m_regiest_product = product;
m_regiest_deviceClass = deviceClass;
}

/// find
{
libusb_device **m_deviceList;
libusb_get_device_list(nullptr, &m_deviceList);
for (int i = 0; m_deviceList[i] != nullptr; i += 1) {
auto device = m_deviceList[i];
struct libusb_device_descriptor descript;
int ret = libusb_get_device_descriptor(device, &descript);
if (ret < 0) {
sprintf(
str,
“Error libusb_get_device_descriptor idx = %d res = %d\n”, i,
ret);
}

if (descript.idVendor == vendor && descript.idProduct == product) {
const int isOpen =
libusb_open(m_deviceList[i], &m_deviceHandle);
if (LIBUSB_SUCCESS == isOpen) {
break;
}
}
}
} /// find

/// test
{
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

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数网络安全工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年网络安全全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上网络安全知识点，真正体系化！

由于文件比较大，这里只是将部分目录大纲截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且后续会持续更新

如果你觉得这些内容对你有帮助，可以添加VX：vip204888 （备注网络安全获取）

还有兄弟不知道网络安全面试可以提前刷题吗？费时一周整理的160+网络安全面试题，金九银十，做网络安全面试里的显眼包！

王岚嵚工程师面试题（附答案），只能帮兄弟们到这儿了！如果你能答对70%，找一个安全工作，问题不大。

对于有1-3年工作经验，想要跳槽的朋友来说，也是很好的温习资料！

【完整版领取方式在文末！！】

93道网络安全面试题

内容实在太多，不一一截图了

黑客学习资源推荐

最后给大家分享一份全套的网络安全学习资料，给那些想学习 网络安全的小伙伴们一点帮助！

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

😝朋友们如果有需要的话，可以联系领取~

1️⃣零基础入门

① 学习路线

对于从来没有接触过网络安全的同学，我们帮你准备了详细的学习成长路线图。可以说是最科学最系统的学习路线，大家跟着这个大的方向学习准没问题。

② 路线对应学习视频

同时每个成长路线对应的板块都有配套的视频提供：

2️⃣视频配套工具&国内外网安书籍、文档

① 工具

② 视频

③ 书籍

资源较为敏感，未展示全面，需要的最下面获取

② 简历模板

因篇幅有限，资料较为敏感仅展示部分资料，添加上方即可获取👆

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算

//img-blog.csdnimg.cn/img_convert/769b7e13b39771b3a6e4397753dab12e.png#pic_center)

资源较为敏感，未展示全面，需要的最下面获取

② 简历模板

因篇幅有限，资料较为敏感仅展示部分资料，添加上方即可获取👆

一个人可以走的很快，但一群人才能走的更远。如果你从事以下工作或对以下感兴趣，欢迎戳这里加入程序员的圈子，让我们一起学习成长！

AI人工智能、Android移动开发、AIGC大模型、C C#、Go语言、Java、Linux运维、云计算、MySQL、PMP、网络安全、Python爬虫、UE5、UI设计、Unity3D、Web前端开发、产品经理、车载开发、大数据、鸿蒙、计算机网络、嵌入式物联网、软件测试、数据结构与算法、音视频开发、Flutter、IOS开发、PHP开发、.NET、安卓逆向、云计算