void c_rpc_server::c_session::read_handler_hmac(const boost::system::error_code &error, std::size_t bytes_transferred) {
_dbg("readed " << bytes_transferred << " bytes of hmac authenticator");
_dbg("authenticate message");
if (error) {
_dbg("asio error " << error.message());
delete_me();
return;
}
int ret = crypto_auth_hmacsha512_verify(m_hmac_authenticator.data(),
reinterpret_cast<const unsigned char *>(m_received_data.data()),
m_received_data.size(),
m_hmac_key.data()
);
if (ret == -1) {
_warn("hmac authentication error");
delete_me();
return;
}
assert(ret == 0);
try {
execute_rpc_command(m_received_data);
} catch (const std::exception &e) {
_erro( "exception read_handler " << e.what());
_erro( "close connection\n" );
delete_me();
return;
}
}
void c_rpc_server::c_session::read_handler_size(const boost::system::error_code &error, std::size_t bytes_transferred) {
_dbg("read handler size");
if (error) {
_dbg("asio error " << error.message());
delete_me();
return;
}
if (bytes_transferred != 2) {
_dbg("bytes_transferred != 2");
delete_me();
return;
}
uint16_t message_size = static_cast<uint16_t>(m_data_size.at(0) << 8);
message_size += m_data_size.at(1);
m_received_data.resize(message_size, 0); // prepare buffer for message
_dbg("message size = " << message_size);
async_read(m_socket, boost::asio::buffer(&m_received_data.at(0), m_received_data.size()),
[this](const boost::system::error_code &error, std::size_t bytes_transferred) {
read_handler_data(error, bytes_transferred);
});
}
void c_rpc_server::c_session::write_handler(const boost::system::error_code &error, std::size_t bytes_transferred) {
UNUSED(bytes_transferred);
try {
if (error) {
_dbg("asio error " << error.message());
delete_me();
return;
}
// continue reading
async_read(m_socket, boost::asio::buffer(&m_data_size.at(0), m_data_size.size()),
[this](const boost::system::error_code &error, std::size_t bytes_transferred) {
read_handler_size(error, bytes_transferred);
});
}
catch (const std::exception &e) {
_erro( "exception in write_handler " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
void c_rpc_server::c_session::read_handler_data(const boost::system::error_code &error, std::size_t bytes_transferred) {
_dbg("readed " << bytes_transferred << " bytes of data");
if (error) {
_dbg("asio error " << error.message());
delete_me();
return;
}
// parsing message
_dbg("received message " << m_received_data);
async_read(m_socket, boost::asio::buffer(&m_hmac_authenticator.at(0), m_hmac_authenticator.size()),
[this](const boost::system::error_code &error, std::size_t bytes_transferred) {
read_handler_hmac(error, bytes_transferred);
});
}
void Device::on_btn_remove_clicked()
{
qDebug()<<"btn_remove_clicked";
qDebug()<<"id"<<this->dev_id;
QMessageBox::StandardButton msgBox= QMessageBox::question(NULL,"Warning !","Do you really want to delete this device?",QMessageBox::Yes|QMessageBox::No);
if(msgBox==QMessageBox::Yes)
{
emit delete_me(this->dev_id);
}
else
{
qDebug()<<"Did not deleted";
}
}
void c_rpc_server::c_session::execute_rpc_command(const std::string &input_message) {
try {
nlohmann::json j = nlohmann::json::parse(input_message);
const std::string cmd_name = j.begin().value();
_dbg("cmd name " << cmd_name);
// calling rpc function
const std::string response = m_rpc_server_ptr->m_rpc_functions_map.at(cmd_name)(input_message);
// serialize response
assert(response.size() <= std::numeric_limits<uint16_t>::max());
uint16_t size = static_cast<uint16_t>(response.size());
m_write_data.resize(size + 2); ///< 2 first bytes for size
m_write_data.at(0) = static_cast<char>(size >> 8);
m_write_data.at(1) = static_cast<char>(size & 0xFF);
for (size_t i = 0; i < response.size(); ++i)
m_write_data.at(i + 2) = response.at(i);
// send response
_dbg("send packet");
_dbg(m_write_data);
std::array<unsigned char, crypto_auth_hmacsha512_BYTES> hash;
int ret = crypto_auth_hmacsha512(hash.data(), reinterpret_cast<unsigned char *>(&m_write_data.at(2)), size, m_rpc_server_ptr->m_hmac_key.data());
if (ret != 0) _throw_error(std::runtime_error("crypto_auth_hmacsha512 error"));
_dbg("hmac");
//for (const auto & byte : hash) std::cout << std::hex << "0x" << static_cast<int>(byte) << " ";
//std::cout << std::dec << std::endl;
std::array<boost::asio::const_buffer, 2> buffers = {
{boost::asio::buffer(m_write_data.data(), m_write_data.size()),
boost::asio::buffer(hash.data(), hash.size())}
};
m_socket.async_write_some(buffers,
[this](const boost::system::error_code& error, std::size_t bytes_transferred) {
write_handler(error, bytes_transferred);
});
}
catch (const std::exception &e) {
_erro( "exception in execute_rpc_command " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
void c_rpc_server::c_session::execute_rpc_command(const std::string &input_message) {
try {
nlohmann::json j = nlohmann::json::parse(input_message);
const std::string cmd_name = j["cmd"];//.begin().value();
dbg("cmd name " << cmd_name);
// calling rpc function
nlohmann::json json_response;
{
LockGuard<Mutex> lg(m_rpc_server_ptr->m_rpc_functions_map_mutex);
json_response = m_rpc_server_ptr->m_rpc_functions_map.at(cmd_name)(input_message);
}
json_response["id"] = get_command_id();
if (j.find("id")!= j.end()) {
json_response["re"] = j["id"];
}
send_response(json_response);
}
catch (const std::exception &e) {
_erro( "exception in execute_rpc_command " << e.what() );
_erro( "close connection\n" );
delete_me();
return;
}
}
void ArchiveWidget::on_tb_delete_clicked()
{
emit delete_me(this);
}