void session::on_http2_connect_server(const boost::system::error_code& error, tcp::resolver::iterator endpoint_iterator)
{
if (error)
{
BOOST_LOG_TRIVIAL(debug) << "[" << session_id << "] " << error.message();
BOOST_LOG_TRIVIAL(error) << "[" << session_id << "] open " << endpoint_iterator->host_name() << " fail";
stop();
return;
}
BOOST_LOG_TRIVIAL(debug) << "[" << session_id << "] open " << endpoint_iterator->host_name();
std::string ack = "HTTP/1.1 200 Connection Established\r\n\r\n";
write_to_client(ack.c_str(), ack.size(), true);
boost::asio::streambuf::mutable_buffers_type buf = read_client_buf.prepare(SOCKET_RECV_BUF_LEN);
client_socket.async_read_some(buf,
strand_.wrap(
boost::bind(&session::on_read_client_data, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred
)
)
);
server_socket.async_read_some(boost::asio::buffer(server_buf, SOCKET_RECV_BUF_LEN),
strand_.wrap(boost::bind(&session::on_read_server_data, shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)
)
);
}
void socks4_stream::name_lookup(asio::error_code const& e, tcp::resolver::iterator i
, boost::shared_ptr<handler_type> h)
{
if (e)
{
(*h)(e);
asio::error_code ec;
close(ec);
return;
}
// SOCKS4 doesn't support IPv6 addresses
while (i != tcp::resolver::iterator() && i->endpoint().address().is_v6())
++i;
if (i == tcp::resolver::iterator())
{
asio::error_code ec = asio::error::operation_not_supported;
(*h)(ec);
close(ec);
return;
}
m_sock.async_connect(i->endpoint(), boost::bind(
&socks4_stream::connected, this, _1, h));
}
void udp_socket::on_name_lookup(error_code const& e, tcp::resolver::iterator i)
{
if (e == asio::error::operation_aborted) return;
CHECK_MAGIC;
if (e)
{
#ifndef BOOST_NO_EXCEPTIONS
try {
#endif
m_callback(e, udp::endpoint(), 0, 0);
#ifndef BOOST_NO_EXCEPTIONS
} catch(std::exception&) {}
#endif
return;
}
mutex_t::scoped_lock l(m_mutex);
m_proxy_addr.address(i->endpoint().address());
m_proxy_addr.port(i->endpoint().port());
l.unlock(); // on_connect may be called from within this thread
m_cc.enqueue(boost::bind(&udp_socket::on_connect, this, _1)
, boost::bind(&udp_socket::on_timeout, this), seconds(10));
}
void udp_socket::on_name_lookup(error_code const& e, tcp::resolver::iterator i)
{
if (e) return;
m_proxy_addr.address(i->endpoint().address());
m_proxy_addr.port(i->endpoint().port());
m_cc.enqueue(boost::bind(&udp_socket::on_connect, this, _1)
, boost::bind(&udp_socket::on_timeout, this), seconds(10));
}
void udp_socket::on_name_lookup(error_code const& e, tcp::resolver::iterator i)
{
#if defined TORRENT_DEBUG || TORRENT_RELEASE_ASSERTS
TORRENT_ASSERT(m_outstanding_resolve > 0);
--m_outstanding_resolve;
#endif
TORRENT_ASSERT(m_outstanding_ops > 0);
--m_outstanding_ops;
TORRENT_ASSERT(m_outstanding_ops == m_outstanding_connect
+ m_outstanding_timeout
+ m_outstanding_resolve
+ m_outstanding_connect_queue
+ m_outstanding_socks);
if (m_abort) return;
CHECK_MAGIC;
if (e == asio::error::operation_aborted) return;
TORRENT_ASSERT(is_single_thread());
if (e)
{
call_handler(e, udp::endpoint(), 0, 0);
drain_queue();
return;
}
m_proxy_addr.address(i->endpoint().address());
m_proxy_addr.port(i->endpoint().port());
// on_connect may be called from within this thread
// the semantics for on_connect and on_timeout is
// a bit complicated. See comments in connection_queue.hpp
// for more details. This semantic determines how and
// when m_outstanding_ops may be decremented
// To simplyfy this, it's probably a good idea to
// merge on_connect and on_timeout to a single function
// on_timeout may be called before on_connected
// so increment the outstanding ops
// it may also not be called in case we call
// connection_queue::done first, so be sure to
// decrement if that happens
m_outstanding_ops += 2;
#if defined TORRENT_DEBUG || TORRENT_RELEASE_ASSERTS
++m_outstanding_timeout;
++m_outstanding_connect_queue;
#endif
m_cc.enqueue(boost::bind(&udp_socket::on_connect, this, _1)
, boost::bind(&udp_socket::on_timeout, this), seconds(10));
}
void EthStratumClient::connect_handler(const boost::system::error_code& ec, tcp::resolver::iterator i)
{
dev::setThreadName("stratum");
if (!ec)
{
m_connected = true;
cnote << "Connected to stratum server " << i->host_name() << ":" << p_active->port;
if (!p_farm->isMining())
{
cnote << "Starting farm";
if (m_minerType == MinerType::CPU)
p_farm->start("cpu");
else if (m_minerType == MinerType::CL)
p_farm->start("opencl");
else if (m_minerType == MinerType::CUDA)
p_farm->start("cuda");
}
std::ostream os(&m_requestBuffer);
os << "{\"id\": 1, \"method\": \"mining.subscribe\", \"params\": []}\n";
async_write(m_socket, m_requestBuffer,
boost::bind(&EthStratumClient::handleResponse, this,
boost::asio::placeholders::error));
}
else
{
cwarn << "Could not connect to stratum server " << p_active->host << ":" << p_active->port << ", " << ec.message();
reconnect();
}
}
bool start_tcp_connect(tcp::resolver::iterator endpoint_iter)
{
bool success= true;
if (endpoint_iter != tcp::resolver::iterator())
{
CLIENT_LOG_INFO("ClientNetworkManager::start_tcp_connect") << "Connecting to: " << endpoint_iter->endpoint() << "..." << std::endl;
// Start the asynchronous connect operation.
m_tcp_socket.async_connect(
endpoint_iter->endpoint(),
boost::bind(&ClientNetworkManagerImpl::handle_tcp_connect, this, _1, endpoint_iter));
}
else
{
// There are no more endpoints to try. Shut down the client.
stop();
success= false;
if (m_netEventListener)
{
m_netEventListener->handle_server_connection_open_failed(boost::asio::error::host_unreachable);
}
}
return success;
}
void http_stream::name_lookup(error_code const& e, tcp::resolver::iterator i
, boost::shared_ptr<handler_type> h)
{
if (handle_error(e, h)) return;
m_sock.async_connect(i->endpoint(), boost::bind(
&http_stream::connected, this, _1, h));
}
void http_stream::name_lookup(error_code const& e, tcp::resolver::iterator i
, handler_type& h)
{
if (handle_error(e, h)) return;
m_sock.async_connect(i->endpoint(), std::bind(
&http_stream::connected, this, _1, std::move(h)));
}
void websocket::handle_resolve(url target, boost::shared_ptr<tcp::resolver> reslv,
error_code const& err, tcp::resolver::iterator endpoint_iterator)
{
if ( check_err(err, "resolve") )
{
tcp_conn_->async_connect(endpoint_iterator->endpoint(), boost::bind(&websocket::handle_connect, this,
target, boost::asio::placeholders::error));
}
}
void start_connect(tcp::resolver::iterator endpoint_iter)
{
if (endpoint_iter != tcp::resolver::iterator())
{
std::cout << "Trying " << endpoint_iter->endpoint() << "...\n";
// Set a deadline for the connect operation.
deadline_.expires_from_now(boost::posix_time::seconds(60));
// Start the asynchronous connect operation.
socket_.async_connect(endpoint_iter->endpoint(),
boost::bind(&client::handle_connect,
this, _1, endpoint_iter));
}
else
{
// There are no more endpoints to try. Shut down the client.
stop();
}
}
void handle_tcp_connect(
const boost::system::error_code& ec,
tcp::resolver::iterator endpoint_iter)
{
if (m_connection_stopped)
return;
// The async_connect() function automatically opens the socket at the start
// of the asynchronous operation. If the socket is closed at this time then
// the timeout handler must have run first.
if (!m_tcp_socket.is_open())
{
CLIENT_LOG_ERROR("ClientNetworkManager::handle_tcp_connect") << "TCP Connect timed out " << std::endl;
if (m_netEventListener)
{
m_netEventListener->handle_server_connection_open_failed(boost::asio::error::timed_out);
}
// Try the next available endpoint.
start_tcp_connect(++endpoint_iter);
}
// Check if the connect operation failed before the deadline expired.
else if (ec)
{
CLIENT_LOG_ERROR("ClientNetworkManager::handle_tcp_connect") << "TCP Connect error: " << ec.message() << std::endl;
if (m_netEventListener)
{
m_netEventListener->handle_server_connection_open_failed(ec);
}
// We need to close the socket used in the previous connection attempt
// before starting a new one.
m_tcp_socket.close();
// Try the next available endpoint.
start_tcp_connect(++endpoint_iter);
}
// Otherwise we have successfully established a connection.
else
{
tcp::endpoint tcp_endpoint= endpoint_iter->endpoint();
CLIENT_LOG_INFO("ClientNetworkManager::handle_tcp_connect") << "Connected to " << tcp_endpoint << std::endl;
// Create a corresponding endpoint udp data will be sent to
m_udp_server_endpoint= udp::endpoint(tcp_endpoint.address(), tcp_endpoint.port());
// Start listening for any incoming responses (TCP messages)
// NOTE: Responses that come independent of a request are a "notification"
start_tcp_read_response_header();
}
}
void http_stream::name_lookup(asio::error_code const& e, tcp::resolver::iterator i
, boost::shared_ptr<handler_type> h)
{
if (e || i == tcp::resolver::iterator())
{
(*h)(e);
close();
return;
}
m_sock.async_connect(i->endpoint(), boost::bind(
&http_stream::connected, this, _1, h));
}
void i2p_stream::do_connect(error_code const& e, tcp::resolver::iterator i
, handler_type h)
{
TORRENT_ASSERT(m_magic == 0x1337);
if (e || i == tcp::resolver::iterator())
{
h(e);
error_code ec;
close(ec);
return;
}
ADD_OUTSTANDING_ASYNC("i2p_stream::connected");
m_sock.async_connect(i->endpoint(), std::bind(
&i2p_stream::connected, this, _1, std::move(h)));
}
void i2p_stream::do_connect(error_code const& e, tcp::resolver::iterator i
, boost::shared_ptr<handler_type> h)
{
TORRENT_ASSERT(m_magic == 0x1337);
if (e || i == tcp::resolver::iterator())
{
(*h)(e);
error_code ec;
close(ec);
return;
}
#if defined TORRENT_ASIO_DEBUGGING
add_outstanding_async("i2p_stream::connected");
#endif
m_sock.async_connect(i->endpoint(), boost::bind(
&i2p_stream::connected, this, _1, h));
}
void handle_connect(const asio::error_code& ec,
tcp::resolver::iterator endpoint_iter)
{
if (stopped_)
return;
// The async_connect() function automatically opens the socket at the start
// of the asynchronous operation. If the socket is closed at this time then
// the timeout handler must have run first.
if (!socket_.is_open())
{
std::cout << "Connect timed out\n";
// Try the next available endpoint.
start_connect(++endpoint_iter);
}
// Check if the connect operation failed before the deadline expired.
else if (ec)
{
std::cout << "Connect error: " << ec.message() << "\n";
// We need to close the socket used in the previous connection attempt
// before starting a new one.
socket_.close();
// Try the next available endpoint.
start_connect(++endpoint_iter);
}
// Otherwise we have successfully established a connection.
else
{
std::cout << "Connected to " << endpoint_iter->endpoint() << "\n";
// Start the input actor.
start_read();
// Start the heartbeat actor.
start_write();
}
}
void resolver::on_lookup(error_code const& ec, tcp::resolver::iterator i
, resolver_interface::callback_t h, std::string hostname)
{
#if defined TORRENT_ASIO_DEBUGGING
complete_async("resolver::on_lookup");
#endif
if (ec)
{
std::vector<address> empty;
h(ec, empty);
return;
}
dns_cache_entry& ce = m_cache[hostname];
time_point now = aux::time_now();
ce.last_seen = now;
ce.addresses.clear();
while (i != tcp::resolver::iterator())
{
ce.addresses.push_back(i->endpoint().address());
++i;
}
h(ec, ce.addresses);
// if m_cache grows too big, weed out the
// oldest entries
if (m_cache.size() > m_max_size)
{
cache_t::iterator oldest = m_cache.begin();
for (cache_t::iterator i = m_cache.begin();
i != m_cache.end(); ++i)
{
if (i->second.last_seen < oldest->second.last_seen)
oldest = i;
}
// remove the oldest entry
m_cache.erase(oldest);
}
}
void WiFiRadioSystem::handleConnect(const boost::system::error_code& error,
tcp::resolver::iterator endpoint_iter, Connection* connection){
if (!connection->socket().is_open())
{
std::cout << "Connect timed out\n";
}
else if (error)
{
std::cout << "Connect error: " << error.message() << "\n";
connection->socket().close();
}
// Otherwise we have successfully established a connection.
else
{
std::cout << "Connected to " << endpoint_iter->endpoint() << "\n";
// Start reading the header
std::cout << "Start reading..." << std::endl;
connection_manager.start(connection);
//start_read_header();
}
}
void EthStratumClient::connect_handler(const boost::system::error_code& ec, tcp::resolver::iterator i)
{
dev::setThreadName("stratum");
if (!ec)
{
m_connected = true;
cnote << "Connected to stratum server " << i->host_name() << ":" << p_active->port;
if (!p_farm->isMining())
{
cnote << "Starting farm";
if (m_minerType == MinerType::CPU)
p_farm->start("cpu", false);
else if (m_minerType == MinerType::CL)
p_farm->start("opencl", false);
else if (m_minerType == MinerType::CUDA)
p_farm->start("cuda", false);
else if (m_minerType == MinerType::Mixed) {
p_farm->start("cuda", false);
p_farm->start("opencl", true);
}
}
std::ostream os(&m_requestBuffer);
string user;
size_t p;
switch (m_protocol) {
case STRATUM_PROTOCOL_STRATUM:
os << "{\"id\": 1, \"method\": \"mining.subscribe\", \"params\": []}\n";
break;
case STRATUM_PROTOCOL_ETHPROXY:
p = p_active->user.find_first_of(".");
user = p_active->user.substr(0, p);
if (p + 1 <= p_active->user.length())
m_worker = p_active->user.substr(p + 1);
else
m_worker = "";
if (m_email.empty())
{
os << "{\"id\": 1, \"worker\":\"" << m_worker << "\", \"method\": \"eth_submitLogin\", \"params\": [\"" << user << "\"]}\n";
}
else
{
os << "{\"id\": 1, \"worker\":\"" << m_worker << "\", \"method\": \"eth_submitLogin\", \"params\": [\"" << user << "\", \"" << m_email << "\"]}\n";
}
break;
case STRATUM_PROTOCOL_ETHEREUMSTRATUM:
os << "{\"id\": 1, \"method\": \"mining.subscribe\", \"params\": [\"ethminer/" << ETH_PROJECT_VERSION << "\",\"EthereumStratum/1.0.0\"]}\n";
break;
}
async_write(m_socket, m_requestBuffer,
boost::bind(&EthStratumClient::handleResponse, this,
boost::asio::placeholders::error));
}
else
{
cwarn << "Could not connect to stratum server " << p_active->host << ":" << p_active->port << ", " << ec.message();
reconnect();
}
}