添加加解密接口支持
This commit is contained in:
parent
14e5778fa3
commit
33545559d3
|
@ -24,41 +24,109 @@
|
|||
|
||||
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// 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)
|
||||
packet->cmd ^= packet->pack_id;
|
||||
pack->cmd ^= pack->pack_id;
|
||||
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)
|
||||
packet->cmd -= packet->pack_id;
|
||||
pack->cmd -= pack->pack_id;
|
||||
|
||||
packet->enc_cmd = cmd_type;
|
||||
packet->encrypt = type;
|
||||
packet->enc_data = enc_data;
|
||||
if (data && size == 0 && type != ENCRYPT_NONE)
|
||||
pack->enc_cmd = cmd_type;
|
||||
if (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;
|
||||
}
|
||||
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)
|
||||
packet->cmd ^= packet->pack_id;
|
||||
else if (packet->enc_cmd == ENCRYPT_CMD_ADD_PID)
|
||||
packet->cmd -= packet->pack_id;
|
||||
else if (packet->enc_cmd == ENCRYPT_CMD_SUB_PID)
|
||||
packet->cmd += packet->pack_id;
|
||||
ret->add_ref();
|
||||
if (pack->enc_cmd == ENCRYPT_CMD_XOR_PID)
|
||||
pack->cmd ^= pack->pack_id;
|
||||
else if (pack->enc_cmd == ENCRYPT_CMD_ADD_PID)
|
||||
pack->cmd -= pack->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;
|
||||
}
|
||||
|
|
|
@ -42,5 +42,5 @@ enum encrypt_cmd
|
|||
//
|
||||
// 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_decrypt(LPPACK_BASE packet, uint8_t* data, size_t size);
|
||||
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(dyn_mem_ptr packet);
|
||||
|
|
|
@ -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_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_SET_ENCRYPT, // 设置加密方式, req = me, ind = 0, val = 0, len = sizeof(PACK_BASE)
|
||||
};
|
||||
enum bulk_status
|
||||
{
|
||||
|
@ -77,7 +78,7 @@ enum packet_cmd
|
|||
PACK_CMD_SCAN_BASE = 200,
|
||||
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
|
||||
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_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
|
||||
|
@ -103,7 +104,7 @@ enum packet_cmd
|
|||
|
||||
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_LOST_CONNECT,
|
||||
SCANNER_STATUS_RESET_BULK,
|
||||
|
|
|
@ -7,6 +7,7 @@
|
|||
#include "../../inc/logs_out.h"
|
||||
#include "sys_util.h"
|
||||
#include "log_util.h"
|
||||
#include "encrypt.h"
|
||||
|
||||
// #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
|
||||
, 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))
|
||||
, enc_head_(ENCRYPT_CMD_NONE), enc_payload_(ENCRYPT_NONE), enc_data_(0)
|
||||
{
|
||||
wait_ep0_ = new linux_event("wait_ep0");
|
||||
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;
|
||||
reply->put(&err, sizeof(err));
|
||||
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:
|
||||
handled = false;
|
||||
}
|
||||
|
@ -382,6 +394,25 @@ int async_usb_gadget::inner_write_bulk(data_source_ptr data, int* err)
|
|||
|
||||
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)
|
||||
{
|
||||
|
@ -664,7 +695,7 @@ void async_usb_gadget::thread_pump_task(void)
|
|||
status_.task_cmd = pack->cmd;
|
||||
status_.task_pack_id = pack->pack_id;
|
||||
used = data->get_rest();
|
||||
reply = handle_cmd_(data, &used, &pack_data);
|
||||
reply = handle_bulk_command(data, &used, &pack_data);
|
||||
if(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 ...
|
||||
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));
|
||||
reply->release();
|
||||
reply = nullptr;
|
||||
|
|
|
@ -77,6 +77,10 @@ class async_usb_gadget : public refer
|
|||
int thread_bulk_in_id_ = -1;
|
||||
int thread_bulk_out_id_ = -1;
|
||||
int thread_restart_id_ = -1;
|
||||
uint32_t enc_head_;
|
||||
uint32_t enc_payload_;
|
||||
uint8_t enc_data_;
|
||||
|
||||
volatile EP0REPLYSTATUS status_;
|
||||
safe_fifo<dyn_mem_ptr> cmd_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);
|
||||
dyn_mem_ptr handle_ctrl_setup(dyn_mem_ptr data); // user command ...
|
||||
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_read_ep0(void);
|
||||
|
|
Binary file not shown.
|
@ -133,7 +133,9 @@ int cmd_result::clean(void)
|
|||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// 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
|
||||
{
|
||||
|
@ -174,7 +176,10 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
|
|||
else
|
||||
{
|
||||
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)
|
||||
{
|
||||
|
@ -187,11 +192,13 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
|
|||
}
|
||||
}
|
||||
else if (pack->cmd == PACK_CMD_SCAN_FINISHED_ROGER)
|
||||
{
|
||||
if (img_receiver_)
|
||||
{
|
||||
data_holder_ptr receiver = img_receiver_(NULL, pack->data);
|
||||
if (receiver)
|
||||
receiver->release();
|
||||
|
||||
}
|
||||
*used = sizeof(PACK_BASE);
|
||||
status_ = pack->data;
|
||||
}
|
||||
|
@ -199,6 +206,8 @@ scanner_handler::scanner_handler(void) : usb_(nullptr), status_(SCANNER_STATUS_N
|
|||
{
|
||||
*used = sizeof(PACK_BASE);
|
||||
status_ = pack->data;
|
||||
if (status_notify_)
|
||||
status_notify_(status_);
|
||||
}
|
||||
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;
|
||||
}
|
||||
void scanner_handler::set_status_notifyer(std::function<void(uint32_t)> stntf)
|
||||
{
|
||||
status_notify_ = stntf;
|
||||
}
|
||||
int scanner_handler::scan_start(void)
|
||||
{
|
||||
auto call = [&](cmd_result* cmd) -> int
|
||||
|
@ -856,6 +869,7 @@ int scanner_handler::open_usb_scanner(libusb_device* dev)
|
|||
ret = usb_->start(dev);
|
||||
if(ret == 0)
|
||||
status_ = SCANNER_STATUS_READY;
|
||||
//usb_->set_gadget_encrypting_method(ENCRYPT_CMD_XOR_PID);
|
||||
}
|
||||
|
||||
return ret;
|
||||
|
|
|
@ -70,6 +70,7 @@ class scanner_handler : public refer
|
|||
async_usb_host* usb_;
|
||||
volatile uint32_t status_;
|
||||
|
||||
std::function<void(uint32_t)> status_notify_;
|
||||
std::function<data_holder_ptr(LPPACKIMAGE, uint64_t)> img_receiver_;
|
||||
|
||||
cmd_result* gen_reply(std::function<int(cmd_result*)> call,
|
||||
|
@ -111,6 +112,7 @@ public:
|
|||
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_status_notifyer(std::function<void(uint32_t)> stntf);
|
||||
int scan_start(void);
|
||||
int scan_stop(void);
|
||||
|
||||
|
|
|
@ -6,11 +6,11 @@
|
|||
|
||||
|
||||
|
||||
|
||||
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
||||
// async_usb_host
|
||||
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)
|
||||
, head_enc_type_(ENCRYPT_CMD_NONE), payload_enc_type_(ENCRYPT_NONE), enc_data_(0)
|
||||
{
|
||||
memset(&bulk_in_, -1, sizeof(bulk_in_));
|
||||
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;
|
||||
}
|
||||
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();
|
||||
|
||||
data->set_len(sizeof(PACK_BASE));
|
||||
BASE_PACKET_REPLY(*pack, cmd, id, 0);
|
||||
enc = packet_encrypt(data, encrypt);
|
||||
data->release();
|
||||
data = enc;
|
||||
|
||||
return data;
|
||||
}
|
||||
|
@ -177,6 +180,19 @@ int async_usb_host::stop(void)
|
|||
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)
|
||||
{
|
||||
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();
|
||||
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)
|
||||
{
|
||||
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)
|
||||
|
@ -497,10 +528,27 @@ int async_usb_host::restart_peer_bulk(uint32_t timeout)
|
|||
|
||||
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)
|
||||
{
|
||||
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);
|
||||
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)
|
||||
{
|
||||
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);
|
||||
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)
|
||||
{
|
||||
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();
|
||||
|
||||
BASE_PACKET_REPLY(*pack, PACK_CMD_SETTING_GET_CUR, pack_id, 0);
|
||||
pack->payload_len = strlen(name) + 1;
|
||||
strcpy(pack->payload, name);
|
||||
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);
|
||||
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),
|
||||
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();
|
||||
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);
|
||||
memcpy(param->data + param->val_off, val, size);
|
||||
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);
|
||||
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)
|
||||
{
|
||||
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);
|
||||
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)
|
||||
{
|
||||
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);
|
||||
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),
|
||||
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();
|
||||
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;
|
||||
strcpy(ptxf->path, remote_path);
|
||||
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);
|
||||
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),
|
||||
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();
|
||||
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;
|
||||
strcpy(ptxf->path, remote_path);
|
||||
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);
|
||||
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),
|
||||
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();
|
||||
|
||||
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 + strlen(from_path) + 1, to_path);
|
||||
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);
|
||||
data->release();
|
||||
|
||||
|
@ -630,13 +708,19 @@ int async_usb_host::file_remove(uint32_t pack_id, const char* file)
|
|||
{
|
||||
int base = sizeof(PACK_BASE),
|
||||
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();
|
||||
|
||||
BASE_PACKET_REPLY(*pack, PACK_CMD_FILE_REMOVE, pack_id, 0);
|
||||
pack->payload_len = datal;
|
||||
strcpy(pack->payload, file);
|
||||
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);
|
||||
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),
|
||||
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();
|
||||
|
||||
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 + strlen(param) + 1, param);
|
||||
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);
|
||||
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));
|
||||
int base = sizeof(PACK_BASE),
|
||||
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();
|
||||
|
||||
BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_STOP, pack_id, 0);
|
||||
pack->payload_len = datal;
|
||||
strcpy(pack->payload, id.c_str());
|
||||
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);
|
||||
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)
|
||||
{
|
||||
dyn_mem_ptr data = dyn_mem::memory(sizeof(PACK_BASE));
|
||||
LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
|
||||
dyn_mem_ptr data(async_usb_host::base_packet(PACK_CMD_PROCESS_REBOOT, pack_id, head_enc_type_));
|
||||
|
||||
BASE_PACKET_REPLY(*pack, PACK_CMD_PROCESS_REBOOT, pack_id, 0);
|
||||
post_2_write_bulk_thread(data);
|
||||
data->release();
|
||||
|
||||
|
|
|
@ -13,6 +13,7 @@
|
|||
#include <vector>
|
||||
#include <algorithm>
|
||||
#include <libusb-1.0/libusb.h>
|
||||
#include <encrypt.h>
|
||||
|
||||
|
||||
typedef struct _usb_ep
|
||||
|
@ -44,6 +45,10 @@ class async_usb_host : public refer
|
|||
safe_fifo<dyn_mem_ptr> in_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_write_bulk(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 inner_write_bulk(data_source_ptr data, int* err);
|
||||
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:
|
||||
async_usb_host(std::function<FUNCTION_PROTO_COMMAND_HANDLE> cmd_handler = std::function<FUNCTION_PROTO_COMMAND_HANDLE>());
|
||||
|
@ -61,16 +66,21 @@ protected:
|
|||
|
||||
public:
|
||||
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:
|
||||
int start(libusb_device* dev);
|
||||
int stop(void);
|
||||
|
||||
uint32_t& encrypt_type_packet_head(void);
|
||||
uint32_t& encrypt_type_payload(void);
|
||||
uint8_t& encrypt_data(void);
|
||||
|
||||
public:
|
||||
int get_peer_protocol_version(uint8_t* main, uint8_t* sub);
|
||||
int get_peer_status(LPEP0REPLYSTATUS status);
|
||||
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 get_settings(uint32_t pack_id);
|
||||
|
|
Loading…
Reference in New Issue