inline boost::system::error_code connect( boost::asio::ip::tcp::socket::lowest_layer_type& socket, boost::asio::ip::tcp::resolver& resolver, const url& u, boost::system::error_code& ec) { // Create a query that corresponds to the url. std::ostringstream port_string; port_string << u.port(); // Get a list of endpoints corresponding to the query. boost::asio::ip::tcp::resolver::results_type endpoints = resolver.resolve(u.host(), port_string.str(), ec); if (ec) return ec; // Try each endpoint until we successfully establish a connection. ec = boost::asio::error::host_not_found; boost::asio::connect(socket, endpoints, ec); if (ec) return ec; // Disable the Nagle algorithm on all sockets. ec = boost::system::error_code(); socket.set_option(boost::asio::ip::tcp::no_delay(true), ec); return ec; }
void do_stop (CompletionCounter) { m_journal.debug << "Stopped"; m_stopped = true; m_work.clear (); m_resolver.cancel (); removeReference (); }
auto dns(Func handler, boost::asio::ip::tcp::resolver& resolver, std::string address, std::string port) { boost::asio::ip::tcp::resolver::query query(address, port); return resolver.async_resolve(query, handler); }
boost::asio::ip::tcp::resolver::iterator WrapResolve( boost::asio::ip::tcp::resolver& resolver, boost::asio::ip::tcp::resolver::query& query, boost::system::error_code* err) { boost::asio::ip::tcp::resolver::iterator resolveIt; if (err == NULL) { resolveIt = resolver.resolve(query); } else { resolveIt = resolver.resolve(query, *err); } //#ifdef STREFLOP_H // (date of note: 08/22/10) // something in resolve() is invalidating the FPU flags streflop::streflop_init<streflop::Simple>(); //#endif return resolveIt; }
void connect(const std::string& host, const std::string& port){ auto endpoint_it = _resolver.resolve({host, port}); boost::asio::async_connect(_socket, endpoint_it, [this](boost::system::error_code ec, boost::asio::ip::tcp::resolver::iterator) { if (!ec) { doReadHeader(); } }); }
//------------------------------------------------------------------------- // Resolver void do_stop (CompletionCounter) { assert (m_stop_called == true); if (m_stopped.exchange (true) == false) { m_work.clear (); m_resolver.cancel (); removeReference (); } }
void do_work (CompletionCounter) { if (m_called_stop.load () == 1) return; // We don't have any work to do at this time if (m_work.empty()) { m_idle = true; m_journal.trace << "Sleeping"; return; } if (m_work.front().names.empty()) m_work.pop_front(); std::string const name (m_work.front().names.back()); HandlerType handler (m_work.front().handler); m_work.front().names.pop_back(); HostAndPort const hp (parseName(name)); if (hp.first.empty()) { m_journal.error << "Unable to parse '" << name << "'"; m_io_service.post (m_strand.wrap (boost::bind ( &NameResolverImpl::do_work, this, CompletionCounter(this)))); return; } boost::asio::ip::tcp::resolver::query query ( hp.first, hp.second); m_resolver.async_resolve (query, boost::bind ( &NameResolverImpl::do_finish, this, name, boost::asio::placeholders::error, handler, boost::asio::placeholders::iterator, CompletionCounter(this))); }
std::vector < std::string > asio_bindings::single_hostname_to_dns(std::string hostname, boost::asio::ip::tcp::resolver& resolver_ptr){ std::vector < std::string > output; try{ boost::asio::ip::tcp::resolver::query query(hostname, ""); boost::asio::ip::tcp::resolver::iterator destination = resolver_ptr.resolve(query); boost::asio::ip::tcp::resolver::iterator end; boost::asio::ip::tcp::endpoint endpoint; while (destination != end){ endpoint = *destination++; output.push_back(endpoint.address().to_string()); } } catch(...){ output.push_back("Not resolved"); } return output; }
std::vector < std::string > asio_bindings::single_ip_to_dns(std::string ip_address, boost::asio::ip::tcp::resolver& resolver_ptr){ std::vector < std::string > output; boost::asio::ip::tcp::endpoint endpoint; try{ boost::asio::ip::address ip = boost::asio::ip::address::from_string(ip_address); endpoint.address(ip); boost::asio::ip::tcp::resolver::iterator destination = resolver_ptr.resolve(endpoint); boost::asio::ip::tcp::resolver::iterator end; for (int i=1; destination != end; destination++, i++) { output.push_back(destination->host_name()); } } catch(...){ output.push_back("Invalid IP address"); } return output; }
void do_work (CompletionCounter) { if (m_stop_called == true) return; // We don't have any work to do at this time if (m_work.empty ()) return; std::string const name (m_work.front ().names.back()); HandlerType handler (m_work.front ().handler); m_work.front ().names.pop_back (); if (m_work.front ().names.empty ()) m_work.pop_front(); HostAndPort const hp (parseName (name)); if (hp.first.empty ()) { JLOG(m_journal.error()) << "Unable to parse '" << name << "'"; m_io_service.post (m_strand.wrap (std::bind ( &ResolverAsioImpl::do_work, this, CompletionCounter (this)))); return; } boost::asio::ip::tcp::resolver::query query ( hp.first, hp.second); m_resolver.async_resolve (query, std::bind ( &ResolverAsioImpl::do_finish, this, name, std::placeholders::_1, handler, std::placeholders::_2, CompletionCounter (this))); }
void start() { if (!_cancelled) _resolver.async_resolve(_q, boost::bind(&FriendConnector::hostResolved, shared_from_this(), asio::placeholders::error, asio::placeholders::iterator)); }