monero-project/monero
monero-project/monero
1
0
Fork 0
mirror of https://github.com/monero-project/monero.git synced 2024-10-30 04:57:36 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #8352

Browse source 
552528b Remove async_blocked_mode_client (Jeffrey Ryan)
3ee2174 string_coding: unused functions (Jeffrey Ryan)
285d9f0 http_server_handlers_map2: dead macros (Jeffrey Ryan)
This commit is contained in:
luigi1111 2022-08-22 22:39:34 -05:00
commit 67a27fb384
No known key found for this signature in database
GPG key ID: F4ACA0183641E010
3 changed files with 0 additions and 233 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

26
contrib/epee/include/net/http_server_handlers_map2.h
View file

@ -63,10 +63,6 @@
bool handled = false; \ bool handled = false; \
if(false) return true; //just a stub to have "else if" if(false) return true; //just a stub to have "else if"
#define MAP_URI2(pattern, callback) else if(std::string::npos != query_info.m_URI.find(pattern)) return callback(query_info, response_info, &m_conn_context);
#define MAP_URI_AUTO_XML2(s_pattern, callback_f, command_type) //TODO: don't think i ever again will use xml - ambiguous and "overtagged" format
#define MAP_URI_AUTO_JON2_IF(s_pattern, callback_f, command_type, cond) \ #define MAP_URI_AUTO_JON2_IF(s_pattern, callback_f, command_type, cond) \
else if((query_info.m_URI == s_pattern) && (cond)) \ else if((query_info.m_URI == s_pattern) && (cond)) \
{ \ { \
@ -139,8 +135,6 @@
MDEBUG( s_pattern << "() processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms"); \ MDEBUG( s_pattern << "() processed with " << ticks1-ticks << "/"<< ticks2-ticks1 << "/" << ticks3-ticks2 << "ms"); \
} }
#define CHAIN_URI_MAP2(callback) else {callback(query_info, response_info, m_conn_context);handled = true;}
#define END_URI_MAP2() return handled;} #define END_URI_MAP2() return handled;}
@ -225,26 +219,6 @@
#define MAP_JON_RPC_WE(method_name, callback_f, command_type) MAP_JON_RPC_WE_IF(method_name, callback_f, command_type, true) #define MAP_JON_RPC_WE(method_name, callback_f, command_type) MAP_JON_RPC_WE_IF(method_name, callback_f, command_type, true)
#define MAP_JON_RPC_WERI(method_name, callback_f, command_type) \
else if(callback_name == method_name) \
{ \
PREPARE_OBJECTS_FROM_JSON(command_type) \
epee::json_rpc::error_response fail_resp = AUTO_VAL_INIT(fail_resp); \
fail_resp.jsonrpc = "2.0"; \
fail_resp.id = req.id; \
MINFO(m_conn_context << "calling RPC method " << method_name); \
bool res = false; \
try { res = callback_f(req.params, resp.result, fail_resp.error, response_info, &m_conn_context); } \
catch (const std::exception &e) { MERROR(m_conn_context << "Failed to " << #callback_f << "(): " << e.what()); } \
if (!res) \
{ \
epee::serialization::store_t_to_json(static_cast<epee::json_rpc::error_response&>(fail_resp), response_info.m_body); \
return true; \
} \
FINALIZE_OBJECTS_TO_JSON(method_name) \
return true;\
}
#define MAP_JON_RPC(method_name, callback_f, command_type) \ #define MAP_JON_RPC(method_name, callback_f, command_type) \
else if(callback_name == method_name) \ else if(callback_name == method_name) \
{ \ { \

113
contrib/epee/include/net/net_helper.h
View file

@ -688,119 +688,6 @@ namespace net_utils
std::atomic<uint64_t> m_bytes_sent; std::atomic<uint64_t> m_bytes_sent;
std::atomic<uint64_t> m_bytes_received; std::atomic<uint64_t> m_bytes_received;
}; };
/************************************************************************/
/* */
/************************************************************************/
class async_blocked_mode_client: public blocked_mode_client
{
public:
async_blocked_mode_client():m_send_deadline(blocked_mode_client::m_io_service)
{
// No deadline is required until the first socket operation is started. We
// set the deadline to positive infinity so that the actor takes no action
// until a specific deadline is set.
m_send_deadline.expires_at(boost::posix_time::pos_infin);
// Start the persistent actor that checks for deadline expiry.
check_send_deadline();
}
~async_blocked_mode_client()
{
m_send_deadline.cancel();
}
bool shutdown()
{
blocked_mode_client::shutdown();
m_send_deadline.cancel();
return true;
}
inline
bool send(const void* data, size_t sz)
{
try
{
/*
m_send_deadline.expires_from_now(boost::posix_time::milliseconds(m_reciev_timeout));
// Set up the variable that receives the result of the asynchronous
// operation. The error code is set to would_block to signal that the
// operation is incomplete. Asio guarantees that its asynchronous
// operations will never fail with would_block, so any other value in
// ec indicates completion.
boost::system::error_code ec = boost::asio::error::would_block;
// Start the asynchronous operation itself. The boost::lambda function
// object is used as a callback and will update the ec variable when the
// operation completes. The blocking_udp_client.cpp example shows how you
// can use boost::bind rather than boost::lambda.
boost::asio::async_write(m_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
// Block until the asynchronous operation has completed.
while(ec == boost::asio::error::would_block)
{
m_io_service.run_one();
}*/
boost::system::error_code ec;
size_t writen = write(data, sz, ec);
if (!writen || ec)
{
LOG_PRINT_L3("Problems at write: " << ec.message());
return false;
}else
{
m_send_deadline.expires_at(boost::posix_time::pos_infin);
}
}
catch(const boost::system::system_error& er)
{
LOG_ERROR("Some problems at connect, message: " << er.what());
return false;
}
catch(...)
{
LOG_ERROR("Some fatal problems.");
return false;
}
return true;
}
private:
boost::asio::deadline_timer m_send_deadline;
void check_send_deadline()
{
// Check whether the deadline has passed. We compare the deadline against
// the current time since a new asynchronous operation may have moved the
// deadline before this actor had a chance to run.
if (m_send_deadline.expires_at() <= boost::asio::deadline_timer::traits_type::now())
{
// The deadline has passed. The socket is closed so that any outstanding
// asynchronous operations are cancelled. This allows the blocked
// connect(), read_line() or write_line() functions to return.
LOG_PRINT_L3("Timed out socket");
m_ssl_socket->next_layer().close();
// There is no longer an active deadline. The expiry is set to positive
// infinity so that the actor takes no action until a new deadline is set.
m_send_deadline.expires_at(boost::posix_time::pos_infin);
}
// Put the actor back to sleep.
m_send_deadline.async_wait(boost::bind(&async_blocked_mode_client::check_send_deadline, this));
}
};
} }
} }

94
contrib/epee/include/string_coding.h
View file

@ -34,100 +34,6 @@ namespace epee
{ {
namespace string_encoding namespace string_encoding
{ {
inline std::string convert_to_ansii(const std::wstring& str_from)
{
std::string res(str_from.begin(), str_from.end());
return res;
/*
std::string result;
std::locale loc;
for(unsigned int i= 0; i < str_from.size(); ++i)
{
result += std::use_facet<std::ctype<wchar_t> >(loc).narrow(str_from[i]);
}
return result;
*/
//return boost::lexical_cast<std::string>(str_from);
/*
std::string str_trgt;
if(!str_from.size())
return str_trgt;
int cb = ::WideCharToMultiByte( code_page, 0, str_from.data(), (__int32)str_from.size(), 0, 0, 0, 0 );
if(!cb)
return str_trgt;
str_trgt.resize(cb);
::WideCharToMultiByte( code_page, 0, str_from.data(), (int)str_from.size(),
(char*)str_trgt.data(), (int)str_trgt.size(), 0, 0);
return str_trgt;*/
}
inline std::string convert_to_ansii(const std::string& str_from)
{
return str_from;
}
inline std::wstring convert_to_unicode(const std::string& str_from)
{
std::wstring result;
std::locale loc;
for(unsigned int i= 0; i < str_from.size(); ++i)
{
result += std::use_facet<std::ctype<wchar_t> >(loc).widen(str_from[i]);
}
return result;
//return boost::lexical_cast<std::wstring>(str_from);
/*
std::wstring str_trgt;
if(!str_from.size())
return str_trgt;
int cb = ::MultiByteToWideChar( code_page, 0, str_from.data(), (int)str_from.size(), 0, 0 );
if(!cb)
return str_trgt;
str_trgt.resize(cb);
::MultiByteToWideChar( code_page, 0, str_from.data(),(int)str_from.size(),
(wchar_t*)str_trgt.data(),(int)str_trgt.size());
return str_trgt;*/
}
inline std::wstring convert_to_unicode(const std::wstring& str_from)
{
return str_from;
}
template<class target_string>
inline target_string convert_to_t(const std::wstring& str_from);
template<>
inline std::string convert_to_t<std::string>(const std::wstring& str_from)
{
return convert_to_ansii(str_from);
}
template<>
inline std::wstring convert_to_t<std::wstring>(const std::wstring& str_from)
{
return str_from;
}
template<class target_string>
inline target_string convert_to_t(const std::string& str_from);
template<>
inline std::string convert_to_t<std::string>(const std::string& str_from)
{
return str_from;
}
template<>
inline std::wstring convert_to_t<std::wstring>(const std::string& str_from)
{
return convert_to_unicode(str_from);
}
inline inline
std::string& base64_chars() std::string& base64_chars()
{ {