lmh188
/
tx-gxx-linux
mirror of http://192.168.1.51:8099/scanner/tx-gxx-linux.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

添加加解密接口支持

This commit is contained in:
gb 2023-04-08 17:24:01 +08:00
parent 14e5778fa3
commit 33545559d3
10 changed files with 284 additions and 51 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

104
device/gxx-linux/usb/src/common/encrypt.cpp
View File

@ -24,40 +24,108 @@
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// exporting api: // exporting api:
dyn_mem_ptr packet_encrypt(LPPACK_BASE packet, uint8_t* data, size_t size, uint32_t cmd_type, uint32_t type, uint8_t enc_data) dyn_mem_ptr packet_encrypt(dyn_mem_ptr packet, uint32_t cmd_type, uint32_t type, uint8_t enc_data)
{ {
dyn_mem_ptr ret = nullptr; dyn_mem_ptr ret = packet;
LPPACK_BASE pack = (LPPACK_BASE)packet->ptr();
ret->add_ref();
if (cmd_type == ENCRYPT_CMD_XOR_PID) if (cmd_type == ENCRYPT_CMD_XOR_PID)
packet->cmd ^= packet->pack_id; pack->cmd ^= pack->pack_id;
else if (cmd_type == ENCRYPT_CMD_ADD_PID) else if (cmd_type == ENCRYPT_CMD_ADD_PID)
packet->cmd += packet->pack_id; pack->cmd += pack->pack_id;
else if (cmd_type == ENCRYPT_CMD_SUB_PID) else if (cmd_type == ENCRYPT_CMD_SUB_PID)
packet->cmd -= packet->pack_id; pack->cmd -= pack->pack_id;
packet->enc_cmd = cmd_type; pack->enc_cmd = cmd_type;
packet->encrypt = type; if (type != ENCRYPT_NONE)
packet->enc_data = enc_data;
if (data && size == 0 && type != ENCRYPT_NONE)
{ {
std::string cont("");
if (type == ENCRYPT_BASE64)
{
}
else if (type == ENCRYPT_AES)
{
}
else if (type == ENCRYPT_ZIP)
{
}
if (cont.length())
{
// space is enough ?
if (cont.length() + sizeof(PACK_BASE) > packet->space())
{
ret->release();
ret = dyn_mem::memory(sizeof(PACK_BASE) + cont.length());
memcpy(ret->ptr(), packet->ptr(), sizeof(PACK_BASE));
pack = (LPPACK_BASE)ret->ptr();
}
// copy cipher text and set encrypt type ...
memcpy(pack->payload, cont.c_str(), cont.length());
ret->set_len(sizeof(PACK_BASE) + cont.length());
pack->payload_len = cont.length();
pack->encrypt = type;
pack->enc_data = enc_data;
}
} }
return ret; return ret;
} }
dyn_mem_ptr packet_decrypt(LPPACK_BASE packet, uint8_t* data, size_t size) dyn_mem_ptr packet_decrypt(dyn_mem_ptr packet)
{ {
dyn_mem_ptr ret = nullptr; dyn_mem_ptr ret = packet;
LPPACK_BASE pack = (LPPACK_BASE)packet->ptr();
if (packet->enc_cmd == ENCRYPT_CMD_XOR_PID) ret->add_ref();
packet->cmd ^= packet->pack_id; if (pack->enc_cmd == ENCRYPT_CMD_XOR_PID)
else if (packet->enc_cmd == ENCRYPT_CMD_ADD_PID) pack->cmd ^= pack->pack_id;
packet->cmd -= packet->pack_id; else if (pack->enc_cmd == ENCRYPT_CMD_ADD_PID)
else if (packet->enc_cmd == ENCRYPT_CMD_SUB_PID) pack->cmd -= pack->pack_id;
packet->cmd += packet->pack_id; else if (pack->enc_cmd == ENCRYPT_CMD_SUB_PID)
pack->cmd += pack->pack_id;
if (data && size && packet->encrypt != ENCRYPT_NONE) if (pack->encrypt != ENCRYPT_NONE && pack->payload_len && packet->get_rest() >= sizeof(PACK_BASE) + pack->payload_len)
{ {
std::string cont("");
if (pack->encrypt == ENCRYPT_BASE64)
{
}
else if (pack->encrypt == ENCRYPT_AES)
{
}
else if (pack->encrypt == ENCRYPT_ZIP)
{
}
if (cont.length())
{
// have out-packet data ?
if (packet->get_rest() > sizeof(PACK_BASE) + pack->payload_len)
cont += std::string(pack->payload + pack->payload_len, packet->get_rest() - (sizeof(PACK_BASE) + pack->payload_len));
// space is enough ?
if (cont.length() + sizeof(PACK_BASE) > packet->space())
{
ret->release();
ret = dyn_mem::memory(sizeof(PACK_BASE) + cont.length());
memcpy(ret->ptr(), packet->ptr(), sizeof(PACK_BASE));
pack = (LPPACK_BASE)ret->ptr();
}
// copy plain text and set encrypt type to none ...
memcpy(pack->payload, cont.c_str(), cont.length());
ret->set_len(sizeof(PACK_BASE) + cont.length());
pack->encrypt = ENCRYPT_NONE;
pack->payload_len = cont.length();
}
} }
return ret; return ret;

4
device/gxx-linux/usb/src/common/encrypt.h
View File

@ -42,5 +42,5 @@ enum encrypt_cmd
// //
// NOTE: nullptr also returned if data was nullptr or size was ZERO // NOTE: nullptr also returned if data was nullptr or size was ZERO
// //
dyn_mem_ptr packet_encrypt(LPPACK_BASE packet, uint8_t* data, size_t size, uint32_t cmd_type = ENCRYPT_CMD_NONE, uint32_t type = ENCRYPT_NONE, uint8_t enc_data = 0); dyn_mem_ptr packet_encrypt(dyn_mem_ptr packet, uint32_t cmd_type = ENCRYPT_CMD_NONE, uint32_t type = ENCRYPT_NONE, uint8_t enc_data = 0);
dyn_mem_ptr packet_decrypt(LPPACK_BASE packet, uint8_t* data, size_t size); dyn_mem_ptr packet_decrypt(dyn_mem_ptr packet);

5
device/gxx-linux/usb/src/common/packet.h
View File

@ -36,6 +36,7 @@ enum ep0_req
USB_REQ_EP0_GET_STATUS, // 获取各工作线程状态, return EP0REPLYSTATUS. req = me, ind = 0, val = 0, len = sizeof(EP0REPLYSTATUS) USB_REQ_EP0_GET_STATUS, // 获取各工作线程状态, return EP0REPLYSTATUS. req = me, ind = 0, val = 0, len = sizeof(EP0REPLYSTATUS)
USB_REQ_EP0_RESET_BULK, // 关闭并重新打开BULK端点, return error number (uint32_t). req = me, ind = 0, val = 0, len = sizeof(uint32_t) USB_REQ_EP0_RESET_BULK, // 关闭并重新打开BULK端点, return error number (uint32_t). req = me, ind = 0, val = 0, len = sizeof(uint32_t)
USB_REQ_EP0_CANCEL_CMD, // 取消当前指令的继续执行（一般用于中止大数据的传输）. req = me, ind = 0, val = 0, len = sizeof(uint32_t) * 2 [(uint32_t)cmd + (uint32_t)pack-id] USB_REQ_EP0_CANCEL_CMD, // 取消当前指令的继续执行（一般用于中止大数据的传输）. req = me, ind = 0, val = 0, len = sizeof(uint32_t) * 2 [(uint32_t)cmd + (uint32_t)pack-id]
USB_REQ_EP0_SET_ENCRYPT, // 设置加密方式， req = me, ind = 0, val = 0, len = sizeof(PACK_BASE)
}; };
enum bulk_status enum bulk_status
{ {
@ -77,7 +78,7 @@ enum packet_cmd
PACK_CMD_SCAN_BASE = 200, PACK_CMD_SCAN_BASE = 200,
PAIR_COMMAND(PACK_CMD_SCAN_START), // start scanning, [in]: PACK_BASE, [out]: PACK_BASE PAIR_COMMAND(PACK_CMD_SCAN_START), // start scanning, [in]: PACK_BASE, [out]: PACK_BASE
PAIR_COMMAND(PACK_CMD_SCAN_IMG), // device -> host, PACK_BASE::payload - LPPACKIMAGE PAIR_COMMAND(PACK_CMD_SCAN_IMG), // device -> host, PACK_BASE::payload - LPPACKIMAGE
PACK_CMD_SCAN_FINISHED_ROGER, // device -> host, PACK_BASE PACK_CMD_SCAN_FINISHED_ROGER, // device -> host, PACK_BASE::data is scanner_status
PAIR_COMMAND(PACK_CMD_SCAN_STOP), // stop scanning, [in]: PACK_BASE, [out]: PACK_BASE PAIR_COMMAND(PACK_CMD_SCAN_STOP), // stop scanning, [in]: PACK_BASE, [out]: PACK_BASE
//PAIR_COMMAND(PACK_CMD_SCAN_IMAGE_REQ), // get image request, [in]: PACK_BASE, [out] PACK_BASE on error, or PACK_BASE::payload - LPPACKIMAGE //PAIR_COMMAND(PACK_CMD_SCAN_IMAGE_REQ), // get image request, [in]: PACK_BASE, [out] PACK_BASE on error, or PACK_BASE::payload - LPPACKIMAGE
//PAIR_COMMAND(PACK_CMD_SCAN_STATUS), // get scanner status, [in]: PACK_BASE, [out] PACK_BASE::result is status code //PAIR_COMMAND(PACK_CMD_SCAN_STATUS), // get scanner status, [in]: PACK_BASE, [out] PACK_BASE::result is status code
@ -103,7 +104,7 @@ enum packet_cmd
enum scanner_status enum scanner_status
{ {
SCANNER_STATUS_READY = 0, SCANNER_STATUS_READY = 0x10000, // status beginning, avoiding conficts with standards/system error code
SCANNER_STATUS_NOT_OPEN, SCANNER_STATUS_NOT_OPEN,
SCANNER_STATUS_LOST_CONNECT, SCANNER_STATUS_LOST_CONNECT,
SCANNER_STATUS_RESET_BULK, SCANNER_STATUS_RESET_BULK,

41
device/gxx-linux/usb/src/common/usb_io.cpp
View File

@ -7,6 +7,7 @@
#include "../../inc/logs_out.h" #include "../../inc/logs_out.h"
#include "sys_util.h" #include "sys_util.h"
#include "log_util.h" #include "log_util.h"
#include "encrypt.h"
// #define TEST // #define TEST
@ -48,6 +49,7 @@ usb_gadget* usb_gadget_config::get_config(void)
async_usb_gadget::async_usb_gadget(usb_gadget* gadget, std::function<FUNCTION_PROTO_UNHANDLED_EP0> unhandled_ep0 async_usb_gadget::async_usb_gadget(usb_gadget* gadget, std::function<FUNCTION_PROTO_UNHANDLED_EP0> unhandled_ep0
, std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler) , std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler)
: gadget_(gadget), unhandled_ep0_(unhandled_ep0), handle_cmd_(cmd_handler), threads_(new thread_pool<async_usb_gadget>(this)) : gadget_(gadget), unhandled_ep0_(unhandled_ep0), handle_cmd_(cmd_handler), threads_(new thread_pool<async_usb_gadget>(this))
, enc_head_(ENCRYPT_CMD_NONE), enc_payload_(ENCRYPT_NONE), enc_data_(0)
{ {
wait_ep0_ = new linux_event("wait_ep0"); wait_ep0_ = new linux_event("wait_ep0");
memset((void*)&status_, 0, sizeof(status_)); memset((void*)&status_, 0, sizeof(status_));
@ -301,6 +303,16 @@ dyn_mem_ptr async_usb_gadget::handle_ctrl_setup(dyn_mem_ptr data)
err = EBUSY; err = EBUSY;
reply->put(&err, sizeof(err)); reply->put(&err, sizeof(err));
break; break;
case USB_REQ_EP0_SET_ENCRYPT:
if (pev->u.setup.wLength == sizeof(PACK_BASE))
{
LPPACK_BASE pack = (LPPACK_BASE)&pev[1];
enc_head_ = pack->enc_cmd;
enc_payload_ = pack->encrypt;
enc_data_ = pack->enc_data;
log_cls::log(LOG_LEVEL_DEBUG, "Set encrypting method: command - %d; payload - %d\n", enc_head_, enc_payload_);
}
break;
default: default:
handled = false; handled = false;
} }
@ -382,6 +394,25 @@ int async_usb_gadget::inner_write_bulk(data_source_ptr data, int* err)
return off; return off;
} }
dyn_mem_ptr async_usb_gadget::handle_bulk_command(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* pkd)
{
dyn_mem_ptr decrypt = packet_decrypt(data);
if (decrypt)
{
data->release();
data = decrypt;
return handle_cmd_(data, used, pkd);
}
else
{
*used = data->get_rest();
*pkd = nullptr;
return nullptr;
}
}
void async_usb_gadget::thread_check_ep0_status(void) void async_usb_gadget::thread_check_ep0_status(void)
{ {
@ -664,7 +695,7 @@ void async_usb_gadget::thread_pump_task(void)
status_.task_cmd = pack->cmd; status_.task_cmd = pack->cmd;
status_.task_pack_id = pack->pack_id; status_.task_pack_id = pack->pack_id;
used = data->get_rest(); used = data->get_rest();
reply = handle_cmd_(data, &used, &pack_data); reply = handle_bulk_command(data, &used, &pack_data);
if(pack_data) if(pack_data)
{ {
dh = dynamic_cast<data_holder_ptr>(pack_data); dh = dynamic_cast<data_holder_ptr>(pack_data);
@ -728,6 +759,14 @@ void async_usb_gadget::thread_pump_task(void)
// first reply the packet ... // first reply the packet ...
if(reply) if(reply)
{ {
// encrypt ...
dyn_mem_ptr enc = packet_encrypt(reply, enc_head_, enc_payload_, enc_data_);
if (enc)
{
reply->release();
reply = enc;
}
write_bulk(dynamic_cast<data_source_ptr>(reply)); write_bulk(dynamic_cast<data_source_ptr>(reply));
reply->release(); reply->release();
reply = nullptr; reply = nullptr;

5
device/gxx-linux/usb/src/common/usb_io.h
View File

@ -77,6 +77,10 @@ class async_usb_gadget : public refer
int thread_bulk_in_id_ = -1; int thread_bulk_in_id_ = -1;
int thread_bulk_out_id_ = -1; int thread_bulk_out_id_ = -1;
int thread_restart_id_ = -1; int thread_restart_id_ = -1;
uint32_t enc_head_;
uint32_t enc_payload_;
uint8_t enc_data_;
volatile EP0REPLYSTATUS status_; volatile EP0REPLYSTATUS status_;
safe_fifo<dyn_mem_ptr> cmd_que_; safe_fifo<dyn_mem_ptr> cmd_que_;
safe_fifo<data_source_ptr> sent_que_; safe_fifo<data_source_ptr> sent_que_;
@ -111,6 +115,7 @@ class async_usb_gadget : public refer
int handle_ctrl_message(dyn_mem_ptr data); int handle_ctrl_message(dyn_mem_ptr data);
dyn_mem_ptr handle_ctrl_setup(dyn_mem_ptr data); // user command ... dyn_mem_ptr handle_ctrl_setup(dyn_mem_ptr data); // user command ...
int inner_write_bulk(data_source_ptr data, int* err = nullptr); int inner_write_bulk(data_source_ptr data, int* err = nullptr);
dyn_mem_ptr handle_bulk_command(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* pkd);
void thread_check_ep0_status(void); void thread_check_ep0_status(void);
void thread_read_ep0(void); void thread_read_ep0(void);

BIN
pc/code_twain/sln/usb_tools/Debug/usb_tools.exe
View File

Binary file not shown.

26
pc/code_twain/sln/usb_tools/scanner/scanner_handler.cpp
View File

@ -133,7 +133,9 @@ int cmd_result::clean(void)
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// scanner_handler // scanner_handler
scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_NOT_OPEN), img_receiver_(std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)>()) scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_NOT_OPEN)
, img_receiver_(std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)>())
, status_notify_(std::function<void(uint32_t)>())
{ {
auto on_reply = [&](dyn_mem_ptr reply, uint32_t* used, packet_data_base_ptr* more) ->dyn_mem_ptr auto on_reply = [&](dyn_mem_ptr reply, uint32_t* used, packet_data_base_ptr* more) ->dyn_mem_ptr
{ {
@ -174,7 +176,10 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
else else
{ {
LPPACKIMAGE pimg = (LPPACKIMAGE)pack->payload; LPPACKIMAGE pimg = (LPPACKIMAGE)pack->payload;
data_holder_ptr receiver = img_receiver_(pimg, pimg->info_size + pimg->data_size); data_holder_ptr receiver = nullptr;
if(img_receiver_)
receiver = img_receiver_(pimg, pimg->info_size + pimg->data_size);
if (!receiver) if (!receiver)
{ {
@ -188,10 +193,12 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
} }
else if (pack->cmd == PACK_CMD_SCAN_FINISHED_ROGER) else if (pack->cmd == PACK_CMD_SCAN_FINISHED_ROGER)
{ {
data_holder_ptr receiver = img_receiver_(NULL, pack->data); if (img_receiver_)
if (receiver) {
receiver->release(); data_holder_ptr receiver = img_receiver_(NULL, pack->data);
if (receiver)
receiver->release();
}
*used = sizeof(PACK_BASE); *used = sizeof(PACK_BASE);
status_ = pack->data; status_ = pack->data;
} }
@ -199,6 +206,8 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
{ {
*used = sizeof(PACK_BASE); *used = sizeof(PACK_BASE);
status_ = pack->data; status_ = pack->data;
if (status_notify_)
status_notify_(status_);
} }
else if (pack->cmd == PACK_CMD_FILE_WRITE_REQ_ROGER) else if (pack->cmd == PACK_CMD_FILE_WRITE_REQ_ROGER)
{ {
@ -556,6 +565,10 @@ void scanner_handler::set_image_receiver(std::function<data_holder_ptr(LPPACKIMA
{ {
img_receiver_ = img; img_receiver_ = img;
} }
void scanner_handler::set_status_notifyer(std::function<void(uint32_t)> stntf)
{
status_notify_ = stntf;
}
int scanner_handler::scan_start(void) int scanner_handler::scan_start(void)
{ {
auto call = [&](cmd_result* cmd) -> int auto call = [&](cmd_result* cmd) -> int
@ -856,6 +869,7 @@ int scanner_handler::open_usb_scanner(libusb_device* dev)
ret = usb_->start(dev); ret = usb_->start(dev);
if(ret == 0) if(ret == 0)
status_ = SCANNER_STATUS_READY; status_ = SCANNER_STATUS_READY;
//usb_->set_gadget_encrypting_method(ENCRYPT_CMD_XOR_PID);
} }
return ret; return ret;

2
pc/code_twain/sln/usb_tools/scanner/scanner_handler.h
View File

@ -70,6 +70,7 @@ class scanner_handler : public refer
async_usb_host* usb_; async_usb_host* usb_;
volatile uint32_t status_; volatile uint32_t status_;
std::function<void(uint32_t)> status_notify_;
std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)> img_receiver_; std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)> img_receiver_;
cmd_result* gen_reply(std::function<int(cmd_result*)> call, cmd_result* gen_reply(std::function<int(cmd_result*)> call,
@ -111,6 +112,7 @@ public:
int status_get(void); int status_get(void);
void set_image_receiver(std::function<data_holder_ptr(LPPACKIMAGE/*NULL when scanning stopped*/, uint64_t/*size in image, error in stopped*/)> img); void set_image_receiver(std::function<data_holder_ptr(LPPACKIMAGE/*NULL when scanning stopped*/, uint64_t/*size in image, error in stopped*/)> img);
void set_status_notifyer(std::function<void(uint32_t)> stntf);
int scan_start(void); int scan_start(void);
int scan_stop(void); int scan_stop(void);

134
pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.cpp
View File

@ -6,11 +6,11 @@
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// async_usb_host // async_usb_host
async_usb_host::async_usb_host(std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler) async_usb_host::async_usb_host(std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler)
: handler_(cmd_handler), usb_dev_(nullptr), usb_handle_(nullptr), run_(true), cancel_write_(false), writing_(false) : handler_(cmd_handler), usb_dev_(nullptr), usb_handle_(nullptr), run_(true), cancel_write_(false), writing_(false)
, head_enc_type_(ENCRYPT_CMD_NONE), payload_enc_type_(ENCRYPT_NONE), enc_data_(0)
{ {
memset(&bulk_in_, -1, sizeof(bulk_in_)); memset(&bulk_in_, -1, sizeof(bulk_in_));
memset(&bulk_out_, -1, sizeof(bulk_out_)); memset(&bulk_out_, -1, sizeof(bulk_out_));
@ -59,13 +59,16 @@ int async_usb_host::enum_usb_endpoints(libusb_device* dev, std::vector<USBEP>& e
return ret; return ret;
} }
dyn_mem_ptr async_usb_host::base_packet(int cmd, uint32_t id) dyn_mem_ptr async_usb_host::base_packet(int cmd, uint32_t id, uint32_t encrypt)
{ {
dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE))); dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE))), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
data->set_len(sizeof(PACK_BASE)); data->set_len(sizeof(PACK_BASE));
BASE_PACKET_REPLY(*pack, cmd, id, 0); BASE_PACKET_REPLY(*pack, cmd, id, 0);
enc = packet_encrypt(data, encrypt);
data->release();
data = enc;
return data; return data;
} }
@ -177,6 +180,19 @@ int async_usb_host::stop(void)
return 0; return 0;
} }
uint32_t& async_usb_host::encrypt_type_packet_head(void)
{
return head_enc_type_; // = ENCRYPT_CMD_NONE;
}
uint32_t& async_usb_host::encrypt_type_payload(void)
{
return payload_enc_type_;
}
uint8_t& async_usb_host::encrypt_data(void)
{
return enc_data_;
}
void async_usb_host::thread_read_bulk(void) void async_usb_host::thread_read_bulk(void)
{ {
dyn_mem_ptr mem = dyn_mem::memory(bulk_in_.max_packet); dyn_mem_ptr mem = dyn_mem::memory(bulk_in_.max_packet);
@ -443,9 +459,24 @@ void async_usb_host::post_2_write_bulk_thread(data_source_ptr data)
data->add_ref(); data->add_ref();
out_que_.save(data, true); out_que_.save(data, true);
} }
dyn_mem_ptr async_usb_host::handle_data_in(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* more) dyn_mem_ptr async_usb_host::handle_data_in(dyn_mem_ptr& data, uint32_t* used, packet_data_base_ptr* more)
{ {
return handler_(data, used, more); dyn_mem_ptr decrypt = packet_decrypt(data);
if (decrypt)
{
data->release();
data = decrypt;
return handler_(data, used, more);
}
else
{
*used = data->get_rest();
*more = nullptr;
return nullptr;
}
} }
int async_usb_host::get_peer_protocol_version(uint8_t* main, uint8_t* sub) int async_usb_host::get_peer_protocol_version(uint8_t* main, uint8_t* sub)
@ -497,10 +528,27 @@ int async_usb_host::restart_peer_bulk(uint32_t timeout)
return err ? err : ok; return err ? err : ok;
} }
int async_usb_host::set_gadget_encrypting_method(uint32_t cmd_enc, uint32_t payload_enc, uint8_t enc_data)
{
dyn_mem_ptr ptr(dyn_mem::memory(sizeof(PACK_BASE)));
LPPACK_BASE pack = (LPPACK_BASE)ptr->ptr();
int err = 0;
pack->size = sizeof(*pack);
pack->enc_cmd = cmd_enc;
pack->encrypt = payload_enc;
pack->enc_data = enc_data;
err = libusb_control_transfer(usb_handle_, LIBUSB_REQUEST_TYPE_VENDOR, USB_REQ_EP0_SET_ENCRYPT, 0, 0
, (unsigned char*)pack, sizeof(*pack)
, 1000);
ptr->release();
return err;
}
int async_usb_host::send_heart_beat(uint32_t pack_id) int async_usb_host::send_heart_beat(uint32_t pack_id)
{ {
dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_HEART_BEAT, pack_id)); dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_HEART_BEAT, pack_id, head_enc_type_));
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -509,7 +557,7 @@ int async_usb_host::send_heart_beat(uint32_t pack_id)
} }
int async_usb_host::get_settings(uint32_t pack_id) int async_usb_host::get_settings(uint32_t pack_id)
{ {
dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SETTING_GET, pack_id)); dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SETTING_GET, pack_id, head_enc_type_));
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -518,13 +566,19 @@ int async_usb_host::get_settings(uint32_t pack_id)
} }
int async_usb_host::get_setting_val(uint32_t pack_id, const char* name) int async_usb_host::get_setting_val(uint32_t pack_id, const char* name)
{ {
dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE) + strlen(name) + 1)); dyn_mem_ptr data(dyn_mem::memory(sizeof(PACK_BASE) + strlen(name) + 1)), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
BASE_PACKET_REPLY(*pack, PACK_CMD_SETTING_GET_CUR, pack_id, 0); BASE_PACKET_REPLY(*pack, PACK_CMD_SETTING_GET_CUR, pack_id, 0);
pack->payload_len = strlen(name) + 1; pack->payload_len = strlen(name) + 1;
strcpy(pack->payload, name); strcpy(pack->payload, name);
data->set_len(sizeof(PACK_BASE) + strlen(name) + 1); data->set_len(sizeof(PACK_BASE) + strlen(name) + 1);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -534,7 +588,7 @@ int async_usb_host::set_setting(uint32_t pack_id, const char* name, int type, vo
{ {
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = strlen(name) + 1 + size; datal = strlen(name) + 1 + size;
dyn_mem_ptr data(dyn_mem::memory(base + datal)); dyn_mem_ptr data(dyn_mem::memory(base + datal)), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
LPCFGVAL param = (LPCFGVAL)pack->payload; LPCFGVAL param = (LPCFGVAL)pack->payload;
@ -546,6 +600,12 @@ int async_usb_host::set_setting(uint32_t pack_id, const char* name, int type, vo
strcpy(param->data, name); strcpy(param->data, name);
memcpy(param->data + param->val_off, val, size); memcpy(param->data + param->val_off, val, size);
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -554,7 +614,7 @@ int async_usb_host::set_setting(uint32_t pack_id, const char* name, int type, vo
int async_usb_host::scan_start(uint32_t pack_id) int async_usb_host::scan_start(uint32_t pack_id)
{ {
dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_START, pack_id)); dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_START, pack_id, head_enc_type_));
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -563,7 +623,7 @@ int async_usb_host::scan_start(uint32_t pack_id)
} }
int async_usb_host::scan_stop(uint32_t pack_id) int async_usb_host::scan_stop(uint32_t pack_id)
{ {
dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_STOP, pack_id)); dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_SCAN_STOP, pack_id, head_enc_type_));
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -575,7 +635,7 @@ int async_usb_host::file_send(uint32_t pack_id, const char* remote_path, uint64_
{ {
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = sizeof(TXFILE) + strlen(remote_path) + 1; datal = sizeof(TXFILE) + strlen(remote_path) + 1;
dyn_mem_ptr data = dyn_mem::memory(base + datal); dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
LPTXFILE ptxf = (LPTXFILE)pack->payload; LPTXFILE ptxf = (LPTXFILE)pack->payload;
@ -585,6 +645,12 @@ int async_usb_host::file_send(uint32_t pack_id, const char* remote_path, uint64_
ptxf->size = size; ptxf->size = size;
strcpy(ptxf->path, remote_path); strcpy(ptxf->path, remote_path);
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -594,7 +660,7 @@ int async_usb_host::file_get(uint32_t pack_id, const char* remote_path, uint64_t
{ {
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = sizeof(TXFILE) + strlen(remote_path) + 1; datal = sizeof(TXFILE) + strlen(remote_path) + 1;
dyn_mem_ptr data = dyn_mem::memory(base + datal); dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
LPTXFILE ptxf = (LPTXFILE)pack->payload; LPTXFILE ptxf = (LPTXFILE)pack->payload;
@ -604,6 +670,12 @@ int async_usb_host::file_get(uint32_t pack_id, const char* remote_path, uint64_t
ptxf->size = 0; ptxf->size = 0;
strcpy(ptxf->path, remote_path); strcpy(ptxf->path, remote_path);
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -613,7 +685,7 @@ int async_usb_host::file_move(uint32_t pack_id, const char* from_path, const cha
{ {
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = strlen(from_path) + 1 + strlen(to_path) + 1; datal = strlen(from_path) + 1 + strlen(to_path) + 1;
dyn_mem_ptr data = dyn_mem::memory(base + datal); dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_MOVE, pack_id, 0); BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_MOVE, pack_id, 0);
@ -621,6 +693,12 @@ int async_usb_host::file_move(uint32_t pack_id, const char* from_path, const cha
strcpy(pack->payload, from_path); strcpy(pack->payload, from_path);
strcpy(pack->payload + strlen(from_path) + 1, to_path); strcpy(pack->payload + strlen(from_path) + 1, to_path);
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -630,13 +708,19 @@ int async_usb_host::file_remove(uint32_t pack_id, const char* file)
{ {
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = strlen(file) + 1; datal = strlen(file) + 1;
dyn_mem_ptr data = dyn_mem::memory(base + datal); dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_REMOVE, pack_id, 0); BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_REMOVE, pack_id, 0);
pack->payload_len = datal; pack->payload_len = datal;
strcpy(pack->payload, file); strcpy(pack->payload, file);
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -647,7 +731,7 @@ int async_usb_host::program_start(uint32_t pack_id, const char* pe_path, const c
{ {
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = strlen(pe_path) + 1 + strlen(param ? param : "") + 1; datal = strlen(pe_path) + 1 + strlen(param ? param : "") + 1;
dyn_mem_ptr data = dyn_mem::memory(base + datal); dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
if (!param) if (!param)
@ -657,6 +741,12 @@ int async_usb_host::program_start(uint32_t pack_id, const char* pe_path, const c
strcpy(pack->payload, pe_path); strcpy(pack->payload, pe_path);
strcpy(pack->payload + strlen(param) + 1, param); strcpy(pack->payload + strlen(param) + 1, param);
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -667,13 +757,19 @@ int async_usb_host::program_stop(uint32_t pack_id, uint64_t pid)
std::string id(std::to_string(pid)); std::string id(std::to_string(pid));
int base = sizeof(PACK_BASE), int base = sizeof(PACK_BASE),
datal = id.length() + 1; datal = id.length() + 1;
dyn_mem_ptr data = dyn_mem::memory(base + datal); dyn_mem_ptr data = dyn_mem::memory(base + datal), enc = nullptr;
LPPACK_BASE pack = (LPPACK_BASE)data->ptr(); LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_STOP, pack_id, 0); BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_STOP, pack_id, 0);
pack->payload_len = datal; pack->payload_len = datal;
strcpy(pack->payload, id.c_str()); strcpy(pack->payload, id.c_str());
data->set_len(base + datal); data->set_len(base + datal);
enc = packet_encrypt(data, head_enc_type_, payload_enc_type_, enc_data_);
if (enc)
{
data->release();
data = enc;
}
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();
@ -681,10 +777,8 @@ int async_usb_host::program_stop(uint32_t pack_id, uint64_t pid)
} }
int async_usb_host::program_reboot(uint32_t pack_id) int async_usb_host::program_reboot(uint32_t pack_id)
{ {
dyn_mem_ptr data = dyn_mem::memory(sizeof(PACK_BASE)); dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_PROCESS_REBOOT, pack_id, head_enc_type_));
LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_REBOOT, pack_id, 0);
post_2_write_bulk_thread(data); post_2_write_bulk_thread(data);
data->release(); data->release();

14
pc/code_twain/sln/usb_tools/scanner/usb/async_usb_host.h
View File

@ -13,6 +13,7 @@
#include <vector> #include <vector>
#include <algorithm> #include <algorithm>
#include <libusb-1.0/libusb.h> #include <libusb-1.0/libusb.h>
#include <encrypt.h>
typedef struct _usb_ep typedef struct _usb_ep
@ -44,6 +45,10 @@ class async_usb_host : public refer
safe_fifo<dyn_mem_ptr> in_que_; safe_fifo<dyn_mem_ptr> in_que_;
safe_fifo<data_source_ptr> out_que_; safe_fifo<data_source_ptr> out_que_;
uint32_t head_enc_type_;
uint32_t payload_enc_type_;
uint8_t enc_data_;
void thread_read_bulk(void); void thread_read_bulk(void);
void thread_write_bulk(void); void thread_write_bulk(void);
void thread_pump_task(void); void thread_pump_task(void);
@ -51,7 +56,7 @@ class async_usb_host : public refer
int bulk_write_buf(uint8_t* buf, int* len); // return error code int bulk_write_buf(uint8_t* buf, int* len); // return error code
int inner_write_bulk(data_source_ptr data, int* err); int inner_write_bulk(data_source_ptr data, int* err);
void post_2_write_bulk_thread(data_source_ptr data); void post_2_write_bulk_thread(data_source_ptr data);
dyn_mem_ptr handle_data_in(dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* more); dyn_mem_ptr handle_data_in(dyn_mem_ptr& data, uint32_t* used, packet_data_base_ptr* more);
public: public:
async_usb_host(std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler = std::function<FUNCTION_PROTO_COMMAND_HANDLE>()); async_usb_host(std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler = std::function<FUNCTION_PROTO_COMMAND_HANDLE>());
@ -61,16 +66,21 @@ protected:
public: public:
static int enum_usb_endpoints(libusb_device* dev, std::vector<USBEP>& eps); static int enum_usb_endpoints(libusb_device* dev, std::vector<USBEP>& eps);
static dyn_mem_ptr base_packet(int cmd, uint32_t id); static dyn_mem_ptr base_packet(int cmd, uint32_t id, uint32_t encrypt = ENCRYPT_CMD_NONE);
public: public:
int start(libusb_device* dev); int start(libusb_device* dev);
int stop(void); int stop(void);
uint32_t& encrypt_type_packet_head(void);
uint32_t& encrypt_type_payload(void);
uint8_t& encrypt_data(void);
public: public:
int get_peer_protocol_version(uint8_t* main, uint8_t* sub); int get_peer_protocol_version(uint8_t* main, uint8_t* sub);
int get_peer_status(LPEP0REPLYSTATUS status); int get_peer_status(LPEP0REPLYSTATUS status);
int restart_peer_bulk(uint32_t timeout = 1000/*ms*/); int restart_peer_bulk(uint32_t timeout = 1000/*ms*/);
int set_gadget_encrypting_method(uint32_t cmd_enc = ENCRYPT_CMD_NONE, uint32_t payload_enc = ENCRYPT_NONE, uint8_t enc_data = 0);
int send_heart_beat(uint32_t pack_id); int send_heart_beat(uint32_t pack_id);
int get_settings(uint32_t pack_id); int get_settings(uint32_t pack_id);