2014-07-25 12:29:08 -04:00
|
|
|
// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
|
2014-03-03 17:07:58 -05:00
|
|
|
// All rights reserved.
|
|
|
|
//
|
2014-07-25 12:29:08 -04:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are met:
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer in the
|
|
|
|
// documentation and/or other materials provided with the distribution.
|
|
|
|
// * Neither the name of the Andrey N. Sabelnikov nor the
|
|
|
|
// names of its contributors may be used to endorse or promote products
|
|
|
|
// derived from this software without specific prior written permission.
|
2014-07-23 09:03:52 -04:00
|
|
|
//
|
2014-07-25 12:29:08 -04:00
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
|
|
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
|
|
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
|
|
|
|
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
|
|
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
|
|
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
|
|
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
|
|
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
2014-07-23 09:03:52 -04:00
|
|
|
//
|
2014-07-25 12:29:08 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
//#include <Winsock2.h>
|
|
|
|
//#include <Ws2tcpip.h>
|
|
|
|
#include <boost/lexical_cast.hpp>
|
|
|
|
#include <iostream>
|
|
|
|
#include <istream>
|
|
|
|
#include <ostream>
|
|
|
|
#include <string>
|
|
|
|
#include <boost/asio.hpp>
|
2017-06-20 11:22:24 -04:00
|
|
|
#include <boost/asio/ssl.hpp>
|
2017-01-25 00:16:05 -05:00
|
|
|
#include <boost/asio/steady_timer.hpp>
|
2014-03-03 17:07:58 -05:00
|
|
|
#include <boost/preprocessor/selection/min.hpp>
|
|
|
|
#include <boost/lambda/bind.hpp>
|
|
|
|
#include <boost/lambda/lambda.hpp>
|
|
|
|
#include <boost/interprocess/detail/atomic.hpp>
|
|
|
|
#include "net/net_utils_base.h"
|
|
|
|
#include "misc_language.h"
|
|
|
|
//#include "profile_tools.h"
|
|
|
|
#include "../string_tools.h"
|
|
|
|
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
#undef MONERO_DEFAULT_LOG_CATEGORY
|
|
|
|
#define MONERO_DEFAULT_LOG_CATEGORY "net"
|
|
|
|
|
2014-03-03 17:07:58 -05:00
|
|
|
#ifndef MAKE_IP
|
|
|
|
#define MAKE_IP( a1, a2, a3, a4 ) (a1|(a2<<8)|(a3<<16)|(a4<<24))
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
namespace epee
|
|
|
|
{
|
|
|
|
namespace net_utils
|
|
|
|
{
|
|
|
|
|
|
|
|
class blocked_mode_client
|
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
struct handler_obj
|
|
|
|
{
|
|
|
|
handler_obj(boost::system::error_code& error, size_t& bytes_transferred):ref_error(error), ref_bytes_transferred(bytes_transferred)
|
|
|
|
{}
|
|
|
|
handler_obj(const handler_obj& other_obj):ref_error(other_obj.ref_error), ref_bytes_transferred(other_obj.ref_bytes_transferred)
|
|
|
|
{}
|
|
|
|
|
|
|
|
boost::system::error_code& ref_error;
|
|
|
|
size_t& ref_bytes_transferred;
|
|
|
|
|
|
|
|
void operator()(const boost::system::error_code& error, // Result of operation.
|
|
|
|
std::size_t bytes_transferred // Number of bytes read.
|
|
|
|
)
|
|
|
|
{
|
|
|
|
ref_error = error;
|
|
|
|
ref_bytes_transferred = bytes_transferred;
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
public:
|
|
|
|
inline
|
2017-06-20 11:22:24 -04:00
|
|
|
blocked_mode_client():m_initialized(false),
|
2014-03-03 17:07:58 -05:00
|
|
|
m_connected(false),
|
|
|
|
m_deadline(m_io_service),
|
2017-06-20 11:22:24 -04:00
|
|
|
m_shutdowned(0),
|
|
|
|
m_ssl(false),
|
|
|
|
m_ctx(boost::asio::ssl::context::sslv23),
|
|
|
|
m_ssl_socket(m_io_service,m_ctx)
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
|
|
|
|
|
|
|
|
m_initialized = true;
|
|
|
|
|
|
|
|
|
|
|
|
// 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.
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// Start the persistent actor that checks for deadline expiry.
|
|
|
|
check_deadline();
|
|
|
|
|
|
|
|
}
|
|
|
|
inline
|
|
|
|
~blocked_mode_client()
|
|
|
|
{
|
|
|
|
//profile_tools::local_coast lc("~blocked_mode_client()", 3);
|
|
|
|
shutdown();
|
|
|
|
}
|
|
|
|
|
|
|
|
inline
|
2017-06-20 11:22:24 -04:00
|
|
|
bool connect(const std::string& addr, int port, std::chrono::milliseconds timeout, bool ssl = false, const std::string& bind_ip = "0.0.0.0")
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
2017-06-20 11:22:24 -04:00
|
|
|
return connect(addr, std::to_string(port), timeout, ssl, bind_ip);
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
inline
|
2017-06-20 11:22:24 -04:00
|
|
|
bool connect(const std::string& addr, const std::string& port, std::chrono::milliseconds timeout, bool ssl = false, const std::string& bind_ip = "0.0.0.0")
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
m_connected = false;
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl = ssl;
|
2014-03-03 17:07:58 -05:00
|
|
|
try
|
|
|
|
{
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl_socket.next_layer().close();
|
|
|
|
|
|
|
|
// Set SSL options
|
|
|
|
// disable sslv2
|
|
|
|
m_ctx.set_options(boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2);
|
|
|
|
m_ctx.set_default_verify_paths();
|
|
|
|
|
2014-03-03 17:07:58 -05:00
|
|
|
// Get a list of endpoints corresponding to the server name.
|
|
|
|
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
boost::asio::ip::tcp::resolver resolver(m_io_service);
|
2016-09-01 13:12:39 -04:00
|
|
|
boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), addr, port, boost::asio::ip::tcp::resolver::query::canonical_name);
|
2014-03-03 17:07:58 -05:00
|
|
|
boost::asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
|
|
|
|
boost::asio::ip::tcp::resolver::iterator end;
|
|
|
|
if(iterator == end)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Failed to resolve " << addr);
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
|
|
|
|
//boost::asio::ip::tcp::endpoint remote_endpoint(boost::asio::ip::address::from_string(addr.c_str()), port);
|
|
|
|
boost::asio::ip::tcp::endpoint remote_endpoint(*iterator);
|
|
|
|
|
|
|
|
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl_socket.next_layer().open(remote_endpoint.protocol());
|
2014-03-03 17:07:58 -05:00
|
|
|
if(bind_ip != "0.0.0.0" && bind_ip != "0" && bind_ip != "" )
|
|
|
|
{
|
|
|
|
boost::asio::ip::tcp::endpoint local_endpoint(boost::asio::ip::address::from_string(addr.c_str()), 0);
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl_socket.next_layer().bind(local_endpoint);
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_from_now(timeout);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
|
|
|
|
boost::system::error_code ec = boost::asio::error::would_block;
|
|
|
|
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl_socket.next_layer().async_connect(remote_endpoint, boost::lambda::var(ec) = boost::lambda::_1);
|
2014-03-03 17:07:58 -05:00
|
|
|
while (ec == boost::asio::error::would_block)
|
|
|
|
{
|
|
|
|
m_io_service.run_one();
|
|
|
|
}
|
|
|
|
|
2017-06-20 11:22:24 -04:00
|
|
|
if (!ec && m_ssl_socket.next_layer().is_open())
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
m_connected = true;
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2017-06-20 11:22:24 -04:00
|
|
|
// SSL Options
|
|
|
|
if(m_ssl) {
|
|
|
|
// Disable verification of host certificate
|
|
|
|
m_ssl_socket.set_verify_mode(boost::asio::ssl::verify_peer);
|
|
|
|
// Handshake
|
|
|
|
m_ssl_socket.next_layer().set_option(boost::asio::ip::tcp::no_delay(true));
|
|
|
|
m_ssl_socket.handshake(boost::asio::ssl::stream_base::client);
|
|
|
|
}
|
2014-03-03 17:07:58 -05:00
|
|
|
return true;
|
|
|
|
}else
|
|
|
|
{
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MWARNING("Some problems at connect, message: " << ec.message());
|
2014-03-03 17:07:58 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
catch(const boost::system::system_error& er)
|
|
|
|
{
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MDEBUG("Some problems at connect, message: " << er.what());
|
2014-03-03 17:07:58 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MDEBUG("Some fatal problems.");
|
2014-03-03 17:07:58 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
|
|
bool disconnect()
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
if(m_connected)
|
|
|
|
{
|
|
|
|
m_connected = false;
|
2017-06-20 11:22:24 -04:00
|
|
|
if(m_ssl)
|
|
|
|
shutdown_ssl();
|
|
|
|
m_ssl_socket.next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both);
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
catch(const boost::system::system_error& /*er*/)
|
|
|
|
{
|
|
|
|
//LOG_ERROR("Some problems at disconnect, message: " << er.what());
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
//LOG_ERROR("Some fatal problems.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
inline
|
2017-01-25 00:16:05 -05:00
|
|
|
bool send(const std::string& buff, std::chrono::milliseconds timeout)
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_from_now(timeout);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// 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.
|
2017-06-20 11:22:24 -04:00
|
|
|
async_write(buff.c_str(), buff.size(), ec);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// Block until the asynchronous operation has completed.
|
|
|
|
while (ec == boost::asio::error::would_block)
|
|
|
|
{
|
|
|
|
m_io_service.run_one();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ec)
|
|
|
|
{
|
|
|
|
LOG_PRINT_L3("Problems at write: " << ec.message());
|
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}else
|
|
|
|
{
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
inline
|
|
|
|
bool send(const void* data, size_t sz)
|
|
|
|
{
|
|
|
|
try
|
|
|
|
{
|
|
|
|
/*
|
|
|
|
m_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;
|
|
|
|
|
2017-06-20 11:22:24 -04:00
|
|
|
size_t writen = write(data, sz, ec);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
if (!writen || ec)
|
|
|
|
{
|
|
|
|
LOG_PRINT_L3("Problems at write: " << ec.message());
|
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}else
|
|
|
|
{
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
catch(const boost::system::system_error& er)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Some problems at send, message: " << er.what());
|
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Some fatal problems.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool is_connected()
|
|
|
|
{
|
2017-06-20 11:22:24 -04:00
|
|
|
return m_connected && m_ssl_socket.next_layer().is_open();
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
inline
|
2017-01-25 00:16:05 -05:00
|
|
|
bool recv(std::string& buff, std::chrono::milliseconds timeout)
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
// Set a deadline for the asynchronous operation. Since this function uses
|
|
|
|
// a composed operation (async_read_until), the deadline applies to the
|
|
|
|
// entire operation, rather than individual reads from the socket.
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_from_now(timeout);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// 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::system::error_code ec = boost::asio::error::would_block;
|
|
|
|
size_t bytes_transfered = 0;
|
|
|
|
|
|
|
|
handler_obj hndlr(ec, bytes_transfered);
|
|
|
|
|
|
|
|
char local_buff[10000] = {0};
|
2017-06-20 11:22:24 -04:00
|
|
|
|
|
|
|
async_read(local_buff, boost::asio::transfer_at_least(1), hndlr);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// Block until the asynchronous operation has completed.
|
|
|
|
while (ec == boost::asio::error::would_block && !boost::interprocess::ipcdetail::atomic_read32(&m_shutdowned))
|
|
|
|
{
|
|
|
|
m_io_service.run_one();
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
if (ec)
|
|
|
|
{
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MTRACE("READ ENDS: Connection err_code " << ec.value());
|
2014-03-03 17:07:58 -05:00
|
|
|
if(ec == boost::asio::error::eof)
|
|
|
|
{
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MTRACE("Connection err_code eof.");
|
2014-03-03 17:07:58 -05:00
|
|
|
//connection closed there, empty
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MDEBUG("Problems at read: " << ec.message());
|
2014-03-03 17:07:58 -05:00
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}else
|
|
|
|
{
|
Change logging to easylogging++
This replaces the epee and data_loggers logging systems with
a single one, and also adds filename:line and explicit severity
levels. Categories may be defined, and logging severity set
by category (or set of categories). epee style 0-4 log level
maps to a sensible severity configuration. Log files now also
rotate when reaching 100 MB.
To select which logs to output, use the MONERO_LOGS environment
variable, with a comma separated list of categories (globs are
supported), with their requested severity level after a colon.
If a log matches more than one such setting, the last one in
the configuration string applies. A few examples:
This one is (mostly) silent, only outputting fatal errors:
MONERO_LOGS=*:FATAL
This one is very verbose:
MONERO_LOGS=*:TRACE
This one is totally silent (logwise):
MONERO_LOGS=""
This one outputs all errors and warnings, except for the
"verify" category, which prints just fatal errors (the verify
category is used for logs about incoming transactions and
blocks, and it is expected that some/many will fail to verify,
hence we don't want the spam):
MONERO_LOGS=*:WARNING,verify:FATAL
Log levels are, in decreasing order of priority:
FATAL, ERROR, WARNING, INFO, DEBUG, TRACE
Subcategories may be added using prefixes and globs. This
example will output net.p2p logs at the TRACE level, but all
other net* logs only at INFO:
MONERO_LOGS=*:ERROR,net*:INFO,net.p2p:TRACE
Logs which are intended for the user (which Monero was using
a lot through epee, but really isn't a nice way to go things)
should use the "global" category. There are a few helper macros
for using this category, eg: MGINFO("this shows up by default")
or MGINFO_RED("this is red"), to try to keep a similar look
and feel for now.
Existing epee log macros still exist, and map to the new log
levels, but since they're used as a "user facing" UI element
as much as a logging system, they often don't map well to log
severities (ie, a log level 0 log may be an error, or may be
something we want the user to see, such as an important info).
In those cases, I tried to use the new macros. In other cases,
I left the existing macros in. When modifying logs, it is
probably best to switch to the new macros with explicit levels.
The --log-level options and set_log commands now also accept
category settings, in addition to the epee style log levels.
2017-01-01 11:34:23 -05:00
|
|
|
MTRACE("READ ENDS: Success. bytes_tr: " << bytes_transfered);
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
/*if(!bytes_transfered)
|
|
|
|
return false;*/
|
|
|
|
|
|
|
|
buff.assign(local_buff, bytes_transfered);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
catch(const boost::system::system_error& er)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Some problems at read, message: " << er.what());
|
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Some fatal problems at read.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2017-01-25 00:16:05 -05:00
|
|
|
inline bool recv_n(std::string& buff, int64_t sz, std::chrono::milliseconds timeout)
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
|
|
|
|
try
|
|
|
|
{
|
|
|
|
// Set a deadline for the asynchronous operation. Since this function uses
|
|
|
|
// a composed operation (async_read_until), the deadline applies to the
|
|
|
|
// entire operation, rather than individual reads from the socket.
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_from_now(timeout);
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// 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.
|
|
|
|
|
|
|
|
buff.resize(static_cast<size_t>(sz));
|
|
|
|
boost::system::error_code ec = boost::asio::error::would_block;
|
|
|
|
size_t bytes_transfered = 0;
|
|
|
|
|
|
|
|
|
|
|
|
handler_obj hndlr(ec, bytes_transfered);
|
2017-06-20 11:22:24 -04:00
|
|
|
async_read((char*)buff.data(), boost::asio::transfer_at_least(buff.size()), hndlr);
|
|
|
|
|
2014-03-03 17:07:58 -05:00
|
|
|
// Block until the asynchronous operation has completed.
|
|
|
|
while (ec == boost::asio::error::would_block && !boost::interprocess::ipcdetail::atomic_read32(&m_shutdowned))
|
|
|
|
{
|
|
|
|
m_io_service.run_one();
|
|
|
|
}
|
|
|
|
|
|
|
|
if (ec)
|
|
|
|
{
|
|
|
|
LOG_PRINT_L3("Problems at read: " << ec.message());
|
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}else
|
|
|
|
{
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
if(bytes_transfered != buff.size())
|
|
|
|
{
|
2017-07-05 03:53:16 -04:00
|
|
|
LOG_ERROR("Transferred mismatch with transfer_at_least value: m_bytes_transferred=" << bytes_transfered << " at_least value=" << buff.size());
|
2014-03-03 17:07:58 -05:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
catch(const boost::system::system_error& er)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Some problems at read, message: " << er.what());
|
|
|
|
m_connected = false;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
catch(...)
|
|
|
|
{
|
|
|
|
LOG_ERROR("Some fatal problems at read.");
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool shutdown()
|
|
|
|
{
|
|
|
|
m_deadline.cancel();
|
2017-06-20 11:22:24 -04:00
|
|
|
boost::system::error_code ec;
|
|
|
|
if(m_ssl)
|
|
|
|
shutdown_ssl();
|
|
|
|
m_ssl_socket.next_layer().cancel(ec);
|
|
|
|
if(ec)
|
|
|
|
MDEBUG("Problems at cancel: " << ec.message());
|
|
|
|
m_ssl_socket.next_layer().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ec);
|
|
|
|
if(ec)
|
|
|
|
MDEBUG("Problems at shutdown: " << ec.message());
|
|
|
|
m_ssl_socket.next_layer().close(ec);
|
|
|
|
if(ec)
|
|
|
|
MDEBUG("Problems at close: " << ec.message());
|
2014-03-03 17:07:58 -05:00
|
|
|
boost::interprocess::ipcdetail::atomic_write32(&m_shutdowned, 1);
|
|
|
|
m_connected = false;
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
void set_connected(bool connected)
|
|
|
|
{
|
|
|
|
m_connected = connected;
|
|
|
|
}
|
|
|
|
boost::asio::io_service& get_io_service()
|
|
|
|
{
|
|
|
|
return m_io_service;
|
|
|
|
}
|
|
|
|
|
|
|
|
boost::asio::ip::tcp::socket& get_socket()
|
|
|
|
{
|
2017-06-20 11:22:24 -04:00
|
|
|
return m_ssl_socket.next_layer();
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
|
|
|
void check_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.
|
2017-01-25 00:16:05 -05:00
|
|
|
if (m_deadline.expires_at() <= std::chrono::steady_clock::now())
|
2014-03-03 17:07:58 -05:00
|
|
|
{
|
|
|
|
// 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_connected = false;
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl_socket.next_layer().close();
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// 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.
|
2017-01-25 00:16:05 -05:00
|
|
|
m_deadline.expires_at(std::chrono::steady_clock::time_point::max());
|
2014-03-03 17:07:58 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
// Put the actor back to sleep.
|
|
|
|
m_deadline.async_wait(boost::bind(&blocked_mode_client::check_deadline, this));
|
|
|
|
}
|
|
|
|
|
2017-06-20 11:22:24 -04:00
|
|
|
void shutdown_ssl() {
|
|
|
|
// ssl socket shutdown blocks if server doesn't respond. We close after 2 secs
|
|
|
|
boost::system::error_code ec = boost::asio::error::would_block;
|
|
|
|
m_deadline.expires_from_now(std::chrono::milliseconds(2000));
|
|
|
|
m_ssl_socket.async_shutdown(boost::lambda::var(ec) = boost::lambda::_1);
|
|
|
|
while (ec == boost::asio::error::would_block)
|
|
|
|
{
|
|
|
|
m_io_service.run_one();
|
|
|
|
}
|
|
|
|
// Ignore "short read" error
|
|
|
|
if (ec.category() == boost::asio::error::get_ssl_category() && ec.value() != ERR_PACK(ERR_LIB_SSL, 0, SSL_R_SHORT_READ))
|
|
|
|
MDEBUG("Problems at ssl shutdown: " << ec.message());
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
bool write(const void* data, size_t sz, boost::system::error_code& ec)
|
|
|
|
{
|
|
|
|
bool success;
|
|
|
|
if(m_ssl)
|
|
|
|
success = boost::asio::write(m_ssl_socket, boost::asio::buffer(data, sz), ec);
|
|
|
|
else
|
|
|
|
success = boost::asio::write(m_ssl_socket.next_layer(), boost::asio::buffer(data, sz), ec);
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
void async_write(const void* data, size_t sz, boost::system::error_code& ec)
|
|
|
|
{
|
|
|
|
if(m_ssl)
|
|
|
|
boost::asio::async_write(m_ssl_socket, boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
|
|
|
|
else
|
|
|
|
boost::asio::async_write(m_ssl_socket.next_layer(), boost::asio::buffer(data, sz), boost::lambda::var(ec) = boost::lambda::_1);
|
|
|
|
}
|
|
|
|
|
|
|
|
void async_read(char* buff, boost::asio::detail::transfer_at_least_t transfer_at_least, handler_obj& hndlr)
|
|
|
|
{
|
|
|
|
if(!m_ssl)
|
|
|
|
boost::asio::async_read(m_ssl_socket.next_layer(), boost::asio::buffer(buff, sizeof(buff)), transfer_at_least, hndlr);
|
|
|
|
else
|
|
|
|
boost::asio::async_read(m_ssl_socket, boost::asio::buffer(buff, sizeof(buff)), transfer_at_least, hndlr);
|
|
|
|
|
|
|
|
}
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
protected:
|
|
|
|
boost::asio::io_service m_io_service;
|
2017-06-20 11:22:24 -04:00
|
|
|
boost::asio::ssl::context m_ctx;
|
|
|
|
boost::asio::ssl::stream<boost::asio::ip::tcp::socket> m_ssl_socket;
|
|
|
|
bool m_ssl;
|
2014-03-03 17:07:58 -05:00
|
|
|
bool m_initialized;
|
|
|
|
bool m_connected;
|
2017-01-25 00:16:05 -05:00
|
|
|
boost::asio::steady_timer m_deadline;
|
2014-03-20 07:46:11 -04:00
|
|
|
volatile uint32_t m_shutdowned;
|
2014-03-03 17:07:58 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************/
|
|
|
|
/* */
|
|
|
|
/************************************************************************/
|
|
|
|
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;
|
|
|
|
|
2017-06-20 11:22:24 -04:00
|
|
|
size_t writen = write(data, sz, ec);
|
|
|
|
|
2014-03-03 17:07:58 -05:00
|
|
|
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");
|
2017-06-20 11:22:24 -04:00
|
|
|
m_ssl_socket.next_layer().close();
|
2014-03-03 17:07:58 -05:00
|
|
|
|
|
|
|
// 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));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
}
|