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));
}
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();
}
}