2023-12-01 09:17:09 +00:00
|
|
|
#include "async_scanner.h"
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
#include <unistd.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <sys/ioctl.h>
|
|
|
|
#include <errno.h>
|
|
|
|
#include <iostream>
|
|
|
|
#include <fstream>
|
|
|
|
|
|
|
|
#include <usb_io.h>
|
|
|
|
#include <sane_opt_json/device_opt.h>
|
|
|
|
#include <sane/sane_ex.h>
|
|
|
|
#include <huagao/hgscanner_error.h>
|
2023-12-18 01:39:48 +00:00
|
|
|
#include "scanner_const_opts.h"
|
2023-12-19 07:27:16 +00:00
|
|
|
#include <hardware.h>
|
2024-01-09 06:26:46 +00:00
|
|
|
#include <sane_opt_json/user.h>
|
|
|
|
#include <base/ui.h>
|
2024-01-16 09:51:34 +00:00
|
|
|
#include <imgprc_mgr.h>
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
2024-01-27 09:43:13 +00:00
|
|
|
#include <malloc.h>
|
2023-12-01 09:17:09 +00:00
|
|
|
|
2024-01-27 09:43:13 +00:00
|
|
|
static void *(*old_malloc_hook)(size_t, const void *) = nullptr;
|
|
|
|
static void (*old_free_hook)(void *ptr, const void *caller) = nullptr;
|
|
|
|
static FILE* g_mem_file = nullptr;
|
|
|
|
static uint64_t total_size = 0;
|
2024-01-29 06:47:35 +00:00
|
|
|
static bool record_ = false;
|
2024-01-27 09:43:13 +00:00
|
|
|
static void * my_malloc_hook(size_t size, const void *caller)
|
|
|
|
{
|
|
|
|
void *result;
|
|
|
|
/* Restore all old hooks */
|
|
|
|
__malloc_hook = old_malloc_hook;
|
2024-01-29 06:47:35 +00:00
|
|
|
if(__malloc_hook == my_malloc_hook)
|
|
|
|
__malloc_hook = nullptr;
|
2024-01-27 09:43:13 +00:00
|
|
|
/* Call recursively */
|
|
|
|
result = malloc(size);
|
|
|
|
/* Save underlying hooks */
|
|
|
|
old_malloc_hook = __malloc_hook;
|
|
|
|
/* printf() might call malloc(), so protect it too. */
|
|
|
|
if(g_mem_file)
|
|
|
|
{
|
|
|
|
char buf[128] = {0};
|
|
|
|
sprintf(buf, "+%p from %p (size = %u)\n", result, caller, size);
|
|
|
|
fwrite(buf, 1, strlen(buf), g_mem_file);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
printf("+%p from %p (size = %u)\n", result, caller, size);
|
|
|
|
/* Restore our own hooks */
|
2024-01-29 06:47:35 +00:00
|
|
|
if(record_)
|
2024-01-27 09:43:13 +00:00
|
|
|
__malloc_hook = my_malloc_hook;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
static void my_free_hook(void *ptr, const void *caller)
|
|
|
|
{
|
|
|
|
__free_hook = old_free_hook;
|
2024-01-29 06:47:35 +00:00
|
|
|
if(__free_hook == my_free_hook)
|
|
|
|
__free_hook = nullptr;
|
2024-01-27 09:43:13 +00:00
|
|
|
if(ptr)
|
|
|
|
free(ptr);
|
|
|
|
if(g_mem_file)
|
|
|
|
{
|
|
|
|
char buf[128] = {0};
|
|
|
|
sprintf(buf, "-%p from %p\n", ptr, caller);
|
|
|
|
fwrite(buf, 1, strlen(buf), g_mem_file);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
printf("-%p from %p\n", ptr, caller);
|
|
|
|
old_free_hook = __free_hook;
|
2024-01-29 06:47:35 +00:00
|
|
|
if(record_)
|
2024-01-27 09:43:13 +00:00
|
|
|
__free_hook = my_free_hook;
|
|
|
|
}
|
2024-01-29 06:47:35 +00:00
|
|
|
void record_malloc(bool enable)
|
2024-01-27 09:43:13 +00:00
|
|
|
{
|
|
|
|
if(enable)
|
|
|
|
{
|
|
|
|
printf("my_malloc_hook = %p, my_free_hook = %p\n", (void*)my_malloc_hook, (void*)my_free_hook);
|
|
|
|
if(g_mem_file)
|
|
|
|
fclose(g_mem_file);
|
|
|
|
g_mem_file = fopen("/tmp/memlog.txt", "wb");
|
|
|
|
std::string log(utils::format_current_time() + "\n");
|
|
|
|
fwrite(log.c_str(), 1, log.length(), g_mem_file);
|
|
|
|
|
2024-01-29 06:47:35 +00:00
|
|
|
record_ = true;
|
2024-01-27 09:43:13 +00:00
|
|
|
old_free_hook = __free_hook;
|
|
|
|
__free_hook = my_free_hook;
|
|
|
|
|
|
|
|
old_malloc_hook = __malloc_hook;
|
|
|
|
__malloc_hook = my_malloc_hook;
|
|
|
|
}
|
|
|
|
else // if(old_malloc_hook)
|
|
|
|
{
|
2024-01-29 06:47:35 +00:00
|
|
|
printf("cancel log malloc.\n");
|
|
|
|
record_ = false;
|
|
|
|
|
|
|
|
// __malloc_hook = old_malloc_hook;
|
|
|
|
// old_malloc_hook = nullptr;
|
|
|
|
|
|
|
|
// __free_hook = old_free_hook;
|
|
|
|
// old_free_hook = nullptr;
|
|
|
|
|
2024-01-27 09:43:13 +00:00
|
|
|
if(g_mem_file)
|
|
|
|
{
|
2024-01-29 06:47:35 +00:00
|
|
|
// std::string log(utils::format_current_time() + "\n");
|
|
|
|
// fwrite(log.c_str(), 1, log.length(), g_mem_file);
|
2024-01-27 09:43:13 +00:00
|
|
|
fclose(g_mem_file);
|
|
|
|
}
|
|
|
|
g_mem_file = nullptr;
|
|
|
|
}
|
|
|
|
}
|
2024-01-29 06:47:35 +00:00
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
|
|
//
|
|
|
|
async_scanner::async_scanner() : usb_(nullptr), cfg_mgr_(nullptr), scan_id_(0)
|
|
|
|
{
|
|
|
|
utils::init_log(LOG_TYPE_FILE);
|
2024-02-20 03:29:26 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "System info: page-size = %u, mapping-page-size = %u, disk-cluster-size = %u, default-stack-size = %u.\n"
|
|
|
|
, global_info::page_size, global_info::page_map_size, global_info::cluster_size, global_info::stack_size);
|
2023-12-01 09:17:09 +00:00
|
|
|
init();
|
|
|
|
|
|
|
|
auto bulk_handle = [&](dyn_mem_ptr data, uint32_t* used, packet_data_base_ptr* required) -> dyn_mem_ptr
|
|
|
|
{
|
|
|
|
LPPACK_BASE pack = (LPPACK_BASE)data->ptr();
|
|
|
|
|
|
|
|
if(used)
|
|
|
|
*used = data->get_rest();
|
2024-01-16 09:51:34 +00:00
|
|
|
|
|
|
|
return handle_bulk_cmd(pack, used, required, data->get_session_id());
|
2023-12-01 09:17:09 +00:00
|
|
|
};
|
2023-12-25 09:39:34 +00:00
|
|
|
auto on_connect = [this](bool connected) -> void
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
utils::to_log(LOG_LEVEL_ALL, "USB %s\n", connected ? "connected" : "dis-connected");
|
2023-12-25 09:39:34 +00:00
|
|
|
connected_ = connected;
|
|
|
|
if(!connected)
|
|
|
|
cis_->stop_scan();
|
2023-12-01 09:17:09 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
auto user = [&](int priv) -> bool
|
|
|
|
{
|
2024-01-05 09:36:50 +00:00
|
|
|
return user_->has_privilege(priv);
|
2023-12-01 09:17:09 +00:00
|
|
|
};
|
|
|
|
auto on_log = [&](const char* msg) -> void
|
|
|
|
{
|
|
|
|
utils::log_info(msg, LOG_LEVEL_DEBUG);
|
|
|
|
};
|
2024-01-05 09:36:50 +00:00
|
|
|
|
2024-01-16 09:51:34 +00:00
|
|
|
auto sender = [this](data_source_ptr img) -> void
|
|
|
|
{
|
2024-01-23 07:07:17 +00:00
|
|
|
if(img->ptr() && ((LPPACK_BASE)img->ptr())->cmd == PACK_CMD_SCAN_FINISHED_ROGER)
|
|
|
|
{
|
|
|
|
cis_->close();
|
|
|
|
utils::print_memory_usage("Memory usage when finished scanning", false);
|
2024-01-29 06:47:35 +00:00
|
|
|
system("sudo cpufreq-set -g ondemand");
|
2024-01-23 07:07:17 +00:00
|
|
|
}
|
|
|
|
|
2024-01-16 09:51:34 +00:00
|
|
|
usb_->write_bulk(img);
|
|
|
|
};
|
|
|
|
|
2024-01-02 07:18:42 +00:00
|
|
|
cfg_mgr_ = new device_option(true, user, on_log);
|
2023-12-25 09:39:34 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "OPT - initializing ...\n");
|
2023-12-18 01:39:48 +00:00
|
|
|
const_opts_ = new scanner_const_opts();
|
2024-01-05 09:36:50 +00:00
|
|
|
user_ = new user_priv();
|
|
|
|
|
2023-12-18 01:39:48 +00:00
|
|
|
cfg_mgr_->add(const_opts_);
|
2024-01-31 01:41:22 +00:00
|
|
|
cis_->set_value(SANE_OPT_NAME(DEVICE_MODEL), &cfg_mgr_->get_option_value(SANE_OPT_NAME(DEVICE_MODEL), SANE_ACTION_GET_VALUE)[0]);
|
2023-12-19 07:27:16 +00:00
|
|
|
cfg_mgr_->add(cis_);
|
2024-01-05 09:36:50 +00:00
|
|
|
cfg_mgr_->add(user_);
|
2024-01-16 09:51:34 +00:00
|
|
|
img_prcr_ = new imgproc_mgr(sender, cfg_mgr_);
|
|
|
|
cfg_mgr_->add(img_prcr_);
|
2023-12-25 09:39:34 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "OPT - initialized %u options.\n", cfg_mgr_->count());
|
2023-12-18 01:39:48 +00:00
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
usb_ = new async_usb_gadget(bulk_handle, on_connect);
|
2023-12-01 10:03:10 +00:00
|
|
|
last_err_ = usb_->last_error();
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
async_scanner::~async_scanner()
|
|
|
|
{
|
2023-12-19 07:27:16 +00:00
|
|
|
if(cis_)
|
|
|
|
{
|
|
|
|
cis_->stop_scan();
|
|
|
|
cis_->close();
|
|
|
|
cis_->release();
|
|
|
|
cis_ = nullptr;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
if(usb_)
|
|
|
|
{
|
|
|
|
usb_->stop();
|
|
|
|
usb_->release();
|
2024-01-16 09:51:34 +00:00
|
|
|
usb_ = nullptr;
|
|
|
|
}
|
|
|
|
if(img_prcr_)
|
|
|
|
{
|
|
|
|
img_prcr_->release();
|
|
|
|
img_prcr_ = nullptr;
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
if(cfg_mgr_)
|
|
|
|
{
|
|
|
|
cfg_mgr_->clear();
|
2023-12-18 01:39:48 +00:00
|
|
|
cfg_mgr_->release();
|
|
|
|
cfg_mgr_ = nullptr;
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
2023-12-09 10:21:05 +00:00
|
|
|
for(auto& v: send_files_)
|
|
|
|
v->release();
|
|
|
|
send_files_.clear();
|
2023-12-18 01:39:48 +00:00
|
|
|
const_opts_->release();
|
2024-01-05 09:36:50 +00:00
|
|
|
user_->release();
|
2023-12-09 10:21:05 +00:00
|
|
|
|
2023-12-01 10:03:10 +00:00
|
|
|
utils::uninit();
|
2024-01-09 06:26:46 +00:00
|
|
|
devui::uninit_ui();
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
|
|
|
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_bulk_cmd(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
LPPACK_BASE pk = nullptr;
|
|
|
|
size_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
|
|
|
|
if(pack->size != base_head_size)
|
|
|
|
{
|
|
|
|
if(used)
|
|
|
|
{
|
|
|
|
utils::log_mem_info("Invalid packet", (uint8_t*)pack, *used);
|
|
|
|
}
|
|
|
|
reply = dyn_mem::memory(base_head_size);
|
|
|
|
LPPACK_BASE p = (LPPACK_BASE)reply->ptr();
|
|
|
|
BASE_PACKET_REPLY(*p, PACK_CMD_INVALID, pack->pack_id, pack->cmd);
|
|
|
|
reply->set_len(base_head_size);
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch(pack->cmd)
|
|
|
|
{
|
|
|
|
case PACK_CMD_SYNC:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_simple_roger(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
case PACK_CMD_SETTING_GET_CUR:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_get_opt_value(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
case PACK_CMD_SETTING_GET:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_get_opt_all(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
case PACK_CMD_SETTING_SET:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_set_opt(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
case PACK_CMD_FILE_WRITE_REQ:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_file_receive(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
case PACK_CMD_FILE_READ_REQ:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_file_send(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
2023-12-09 10:21:05 +00:00
|
|
|
case PACK_CMD_FILE_READ_REQ_ROGER:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_file_send_roger(pack, used, required, session);
|
2023-12-09 10:21:05 +00:00
|
|
|
break;
|
2023-12-01 09:17:09 +00:00
|
|
|
case PACK_CMD_SCAN_START:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_scan_start(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
case PACK_CMD_SCAN_STOP:
|
2024-01-16 09:51:34 +00:00
|
|
|
reply = handle_scan_stop(pack, used, required, session);
|
2023-12-01 09:17:09 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if(used)
|
|
|
|
{
|
|
|
|
utils::log_mem_info("Unsupported command packet", (uint8_t*)pack, *used);
|
|
|
|
}
|
|
|
|
reply = dyn_mem::memory(base_head_size);
|
|
|
|
LPPACK_BASE p = (LPPACK_BASE)reply->ptr();
|
|
|
|
BASE_PACKET_REPLY(*p, pack->cmd + 1, pack->pack_id, EINVAL);
|
|
|
|
reply->set_len(base_head_size);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
|
|
|
void async_scanner::init(void)
|
|
|
|
{
|
2023-12-19 07:27:16 +00:00
|
|
|
cis_ = new scanner_hw();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
auto uicb = [this](devui::LPMSGSTREAM pack) -> void
|
2024-01-09 06:26:46 +00:00
|
|
|
{
|
2024-02-07 04:43:27 +00:00
|
|
|
if(devui::UI_CMD_COUNT_PAPER == pack->msg)
|
|
|
|
{
|
|
|
|
auto receiver = [this](dyn_mem_ptr data, bool img, LPPACKIMAGE lpinfo) -> void
|
|
|
|
{
|
|
|
|
img_prcr_->process(lpinfo, data, img);
|
|
|
|
};
|
|
|
|
bool auto_scan = true;
|
|
|
|
std::string prev(cfg_mgr_->get_option_value(SANE_OPT_NAME(WAIT_TO_SCAN), SANE_ACTION_GET_VALUE));
|
|
|
|
cis_->set_value(SANE_OPT_NAME(WAIT_TO_SCAN), &auto_scan);
|
|
|
|
cis_->open(receiver, nullptr, true);
|
|
|
|
cis_->start_scan();
|
|
|
|
}
|
|
|
|
else if(devui::UI_CMD_STOP_SCAN == pack->msg)
|
|
|
|
{
|
|
|
|
cis_->stop_scan();
|
2024-01-09 06:26:46 +00:00
|
|
|
|
2024-02-07 04:43:27 +00:00
|
|
|
bool auto_scan = false;
|
|
|
|
cis_->set_value(SANE_OPT_NAME(WAIT_TO_SCAN), &auto_scan);
|
|
|
|
}
|
2024-01-09 06:26:46 +00:00
|
|
|
};
|
2024-02-07 04:43:27 +00:00
|
|
|
|
|
|
|
devui::init_ui(uicb, false);
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
2024-01-05 09:36:50 +00:00
|
|
|
bool async_scanner::on_energy_conservation(bool normal)
|
|
|
|
{
|
|
|
|
bool enable = true;
|
|
|
|
|
|
|
|
if(normal)
|
|
|
|
{
|
|
|
|
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
if(cis_->is_scanning())
|
|
|
|
enable = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return enable;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_simple_roger(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = dyn_mem::memory(base_head_size);
|
|
|
|
LPPACK_BASE pk = (LPPACK_BASE)reply->ptr();
|
|
|
|
|
|
|
|
*used = base_head_size;
|
|
|
|
BASE_PACKET_REPLY(*pk, pack->cmd + 1, pack->pack_id, 0);
|
|
|
|
reply->set_len(base_head_size);
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_get_opt_value(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
LPPACK_BASE pk = nullptr;
|
|
|
|
|
|
|
|
if(*used < base_head_size + pack->payload_len)
|
|
|
|
{
|
|
|
|
*used = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
std::string val(cfg_mgr_->get_option_value(pack->payload, SANE_ACTION_GET_VALUE));
|
|
|
|
uint32_t err = val.empty() ? SCANNER_ERR_NO_DATA : SCANNER_ERR_OK;
|
|
|
|
LPCFGVAL cfg = nullptr;
|
|
|
|
|
|
|
|
reply = dyn_mem::memory(base_head_size + sizeof(CFGVAL) + strlen(pack->payload) + 1 + val.length() + 1);
|
|
|
|
pk = (LPPACK_BASE)reply->ptr();
|
|
|
|
BASE_PACKET_REPLY(*pk, pack->cmd + 1, pack->pack_id, err);
|
|
|
|
cfg = (LPCFGVAL)pk->payload;
|
|
|
|
cfg->val_size = val.length();
|
|
|
|
cfg->val_off = 0;
|
|
|
|
cfg->name_off = val.length() + 1;
|
|
|
|
pk->payload_len = sizeof(CFGVAL) + strlen(pack->payload) + 1 + val.length() + 1;
|
|
|
|
memcpy(cfg->data, val.c_str(), val.length());
|
|
|
|
strcpy(cfg->data + cfg->name_off, pack->payload);
|
|
|
|
reply->set_len(base_head_size + pk->payload_len);
|
|
|
|
*used = base_head_size + pack->payload_len;
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_get_opt_all(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
LPPACK_BASE pk = nullptr;
|
|
|
|
|
|
|
|
*used = base_head_size;
|
|
|
|
{
|
|
|
|
std::string val(cfg_mgr_->get_option_value(nullptr, SANE_ACTION_GET_ENTIRE_JSON));
|
|
|
|
uint32_t err = 0;
|
|
|
|
|
|
|
|
reply = dyn_mem::memory(base_head_size + val.length() + 1);
|
|
|
|
pk = (LPPACK_BASE)reply->ptr();
|
|
|
|
BASE_PACKET_REPLY(*pk, pack->cmd + 1, pack->pack_id, err);
|
|
|
|
strcpy(pk->payload, val.c_str());
|
|
|
|
pk->payload_len = val.length() + 1;
|
|
|
|
reply->set_len(base_head_size + val.length() + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_set_opt(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2024-01-05 09:36:50 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
2023-12-01 09:17:09 +00:00
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
LPPACK_BASE pk = nullptr;
|
|
|
|
|
|
|
|
if (*used < base_head_size + pack->payload_len)
|
|
|
|
*used = 0;
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LPCFGVAL cfg = (LPCFGVAL)pack->payload,
|
|
|
|
cfg_ret = nullptr;
|
|
|
|
std::string name(cfg->data + cfg->name_off);
|
|
|
|
size_t l = base_head_size + sizeof(CFGVAL) + name.length() + 1 + cfg->max_size + 1, val_size = cfg->val_size;
|
|
|
|
int32_t err = 0;
|
|
|
|
uint32_t after = 0;
|
|
|
|
|
|
|
|
reply = dyn_mem::memory(l);
|
|
|
|
pk = (LPPACK_BASE)reply->ptr();
|
|
|
|
cfg_ret = (LPCFGVAL)pk->payload;
|
|
|
|
cfg_ret->name_off = 0;
|
|
|
|
strcpy(cfg_ret->data + cfg_ret->name_off, name.c_str());
|
|
|
|
cfg_ret->val_off = name.length() + 1;
|
|
|
|
memcpy(cfg_ret->data + cfg_ret->val_off, cfg->data + cfg->val_off, cfg->val_size);
|
|
|
|
cfg_ret->val_size = cfg->val_size;
|
|
|
|
cfg_ret->max_size = cfg->max_size;
|
|
|
|
cfg_ret->type = cfg->type;
|
|
|
|
err = cfg_mgr_->update_data(cfg->data + cfg->name_off, cfg_ret->data + cfg_ret->val_off);
|
2023-12-26 03:30:26 +00:00
|
|
|
if(err == SCANNER_ERR_RELOAD_OPT_PARAM || err == SCANNER_ERR_RELOAD_IMAGE_PARAM || err == SCANNER_ERR_CONFIGURATION_CHANGED)
|
|
|
|
{
|
|
|
|
after = err;
|
|
|
|
err = SCANNER_ERR_OK;
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
cfg_ret->after_do = after;
|
|
|
|
cfg_ret->val_size = val_size;
|
|
|
|
BASE_PACKET_REPLY(*pk, pack->cmd + 1, pack->pack_id, err);
|
|
|
|
pk->payload_len = sizeof(CFGVAL) + name.length() + 1 + cfg->max_size + 1;
|
|
|
|
reply->set_len(l);
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_file_receive(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
LPPACK_BASE pk = nullptr;
|
|
|
|
|
|
|
|
if(*used < pack->payload_len + pack->size)
|
|
|
|
{
|
|
|
|
*used = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LPTXFILE pfi = (LPTXFILE)pack->payload;
|
|
|
|
std::string path(pfi->path);
|
|
|
|
int err = 0;
|
|
|
|
file_saver *saver = new file_saver();
|
|
|
|
|
2023-12-09 10:21:05 +00:00
|
|
|
err = saver->open(path.c_str(), pfi->size, true, pfi->offset);
|
2023-12-01 09:17:09 +00:00
|
|
|
reply = dyn_mem::memory(base_head_size);
|
|
|
|
reply->set_len(base_head_size);
|
|
|
|
BASE_PACKET_REPLY(*((LPPACK_BASE)reply->ptr()), pack->cmd + 1, pack->pack_id, err);
|
|
|
|
*used = base_head_size + pack->payload_len;
|
|
|
|
if(err)
|
|
|
|
{
|
|
|
|
saver->release();
|
|
|
|
saver = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
saver->set_packet_param(pack->cmd, pack->pack_id);
|
|
|
|
}
|
2023-12-13 06:57:08 +00:00
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Receiving file(%p bytes): %s = %d\n", pfi->size, path.c_str(), err);
|
2023-12-01 09:17:09 +00:00
|
|
|
*required = dynamic_cast<packet_data_base_ptr>(saver);
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_file_send(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = dyn_mem::memory(base_head_size);
|
|
|
|
LPPACK_BASE pk = (LPPACK_BASE)reply->ptr();
|
|
|
|
|
|
|
|
if(*used < pack->payload_len + pack->size)
|
|
|
|
{
|
|
|
|
*used = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
LPTXFILE pfi = (LPTXFILE)pack->payload;
|
|
|
|
std::string path(pfi->path);
|
|
|
|
int err = 0;
|
|
|
|
file_reader *reader = new file_reader();
|
|
|
|
|
2023-12-09 10:21:05 +00:00
|
|
|
err = reader->open(path.c_str(), true, pfi->offset);
|
2023-12-01 09:17:09 +00:00
|
|
|
reply = dyn_mem::memory(base_head_size + sizeof(TXFILE));
|
|
|
|
reply->set_len(base_head_size + sizeof(TXFILE));
|
|
|
|
BASE_PACKET_REPLY(*((LPPACK_BASE)reply->ptr()), pack->cmd + 1, pack->pack_id, err);
|
2023-12-29 08:25:05 +00:00
|
|
|
((LPPACK_BASE)reply->ptr())->payload_len = sizeof(TXFILE);
|
2023-12-01 09:17:09 +00:00
|
|
|
*used = base_head_size + pack->payload_len;
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "To send file '%s' with %u bytes = %d\n", path.c_str(), reader->get_rest(), err);
|
|
|
|
if(err)
|
|
|
|
{
|
|
|
|
reader->release();
|
|
|
|
reader = nullptr;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
((LPTXFILE)((LPPACK_BASE)reply->ptr())->payload)->size = reader->get_rest();
|
|
|
|
reader->set_packet_param(pack->cmd, pack->pack_id);
|
2023-12-09 10:21:05 +00:00
|
|
|
{
|
|
|
|
// move to PACK_CMD_FILE_READ_REQ_ROGER
|
|
|
|
SIMPLE_LOCK(fsender_);
|
|
|
|
send_files_.push_back(reader);
|
|
|
|
reader = nullptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*required = dynamic_cast<packet_data_base_ptr>(reader);
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_file_send_roger(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-09 10:21:05 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
|
|
|
|
if(*used < base_head_size)
|
|
|
|
{
|
|
|
|
*used = 0;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
file_reader* reader = nullptr;
|
|
|
|
|
|
|
|
{
|
|
|
|
SIMPLE_LOCK(fsender_);
|
|
|
|
for(size_t i = 0; i < send_files_.size(); ++i)
|
|
|
|
{
|
|
|
|
if(send_files_[i]->get_packet_id() == pack->pack_id)
|
|
|
|
{
|
|
|
|
reader = send_files_[i];
|
|
|
|
send_files_.erase(send_files_.begin() + i);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
2023-12-13 06:57:08 +00:00
|
|
|
|
2023-12-29 08:25:05 +00:00
|
|
|
if(!reader)
|
|
|
|
{
|
|
|
|
utils::log_mem_info("FATAL: Sending file lost source object !!!", pack, *used, LOG_LEVEL_FATAL);
|
|
|
|
}
|
|
|
|
else if(pack->data)
|
2023-12-13 06:57:08 +00:00
|
|
|
{
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Sending file '%s' (%p) cancelled with error %d.\n", reader->path_file(), reader, pack->data);
|
|
|
|
reader->release();
|
|
|
|
reader = nullptr;
|
|
|
|
}
|
2023-12-29 08:25:05 +00:00
|
|
|
else
|
2023-12-13 06:57:08 +00:00
|
|
|
{
|
|
|
|
// if reader was nullptr, notify failed by INT or control ?
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Sending file '%s' (%p) ...\n", reader->path_file(), reader);
|
|
|
|
}
|
2023-12-29 08:25:05 +00:00
|
|
|
*used = base_head_size;
|
2023-12-01 09:17:09 +00:00
|
|
|
*required = dynamic_cast<packet_data_base_ptr>(reader);
|
|
|
|
}
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_scan_start(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
if(!used)
|
|
|
|
{
|
|
|
|
reply_start_ = true;
|
|
|
|
return nullptr;
|
|
|
|
}
|
|
|
|
|
2024-01-23 07:07:17 +00:00
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = nullptr;
|
|
|
|
std::string config("");
|
2023-12-01 09:17:09 +00:00
|
|
|
|
|
|
|
img_cnt_ = 0;
|
|
|
|
scan_id_ = pack->pack_id;
|
|
|
|
scan_err_ = 0;
|
|
|
|
reply_start_ = false;
|
|
|
|
|
2024-01-09 06:26:46 +00:00
|
|
|
auto receiver = [this](dyn_mem_ptr data, bool img, LPPACKIMAGE lpinfo) -> void
|
2023-12-29 02:53:04 +00:00
|
|
|
{
|
2024-01-16 09:51:34 +00:00
|
|
|
img_prcr_->process(lpinfo, data, img);
|
2023-12-29 02:53:04 +00:00
|
|
|
};
|
|
|
|
|
2024-01-23 07:07:17 +00:00
|
|
|
utils::print_memory_usage("Memory usage before scanning", false);
|
2023-12-01 09:17:09 +00:00
|
|
|
*used = base_head_size;
|
2024-01-16 09:51:34 +00:00
|
|
|
img_prcr_->start_new_turn(scan_id_, session);
|
2024-01-23 07:07:17 +00:00
|
|
|
scan_err_ = cis_->open(receiver, &config);
|
|
|
|
reply = dyn_mem::memory(base_head_size + config.length() + 2);
|
|
|
|
reply->set_len(base_head_size + config.length() + 2);
|
2023-12-29 02:53:04 +00:00
|
|
|
if(scan_err_ == 0)
|
|
|
|
scan_err_ = cis_->start_scan();
|
2024-01-03 09:39:16 +00:00
|
|
|
if(scan_err_)
|
|
|
|
{
|
|
|
|
cis_->stop_scan();
|
2024-01-29 06:47:35 +00:00
|
|
|
cis_->close();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
system("echo performance > /sys/devices/system/cpu/cpu5/cpufreq/scaling_governor");
|
2023-12-01 09:17:09 +00:00
|
|
|
BASE_PACKET_REPLY(*((LPPACK_BASE)reply->ptr()), pack->cmd + 1, pack->pack_id, scan_err_);
|
2024-01-23 07:07:17 +00:00
|
|
|
((LPPACK_BASE)reply->ptr())->payload_len = config.length() + 2;
|
|
|
|
strcpy(((LPPACK_BASE)reply->ptr())->payload, config.c_str());
|
2023-12-01 09:17:09 +00:00
|
|
|
*used |= INT32_MAX + 1;
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_scan_stop(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = dyn_mem::memory(base_head_size);
|
|
|
|
int err = 0;
|
|
|
|
|
|
|
|
utils::to_log(LOG_LEVEL_DEBUG, "Received command Stop-Scan.\n");
|
2023-12-29 02:53:04 +00:00
|
|
|
err = cis_->stop_scan();
|
2023-12-01 09:17:09 +00:00
|
|
|
BASE_PACKET_REPLY(*((LPPACK_BASE)reply->ptr()), pack->cmd + 1, pack->pack_id, err);
|
|
|
|
reply->set_len(base_head_size);
|
|
|
|
*used = base_head_size;
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
2024-01-16 09:51:34 +00:00
|
|
|
dyn_mem_ptr async_scanner::handle_process_cmd(LPPACK_BASE pack, uint32_t* used, packet_data_base_ptr* required, uint32_t session)
|
2023-12-01 09:17:09 +00:00
|
|
|
{
|
|
|
|
uint32_t base_head_size = sizeof(PACK_BASE);
|
|
|
|
dyn_mem_ptr reply = dyn_mem::memory(base_head_size);
|
|
|
|
LPPACK_BASE pk = (LPPACK_BASE)reply->ptr();
|
|
|
|
|
|
|
|
*used = base_head_size + pack->payload_len;
|
|
|
|
BASE_PACKET_REPLY(*pk, pack->cmd + 1, pack->pack_id, EINVAL);
|
|
|
|
reply->set_len(base_head_size);
|
|
|
|
|
|
|
|
return reply;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
uint32_t async_scanner::stop(void)
|
|
|
|
{
|
2024-01-16 09:51:34 +00:00
|
|
|
if(img_prcr_)
|
|
|
|
img_prcr_->stop();
|
|
|
|
|
2023-12-01 09:17:09 +00:00
|
|
|
if(usb_)
|
|
|
|
{
|
|
|
|
usb_->stop();
|
|
|
|
}
|
2023-12-26 01:33:05 +00:00
|
|
|
|
|
|
|
return 0;
|
2023-12-01 09:17:09 +00:00
|
|
|
}
|
2023-12-01 10:03:10 +00:00
|
|
|
int async_scanner::last_error(void)
|
|
|
|
{
|
|
|
|
return last_err_;
|
|
|
|
}
|
2024-01-27 09:43:13 +00:00
|
|
|
|