void
TCPConnection::StartAsyncConnect_(const String &ip_adress, int port)
{
IPAddress adress;
adress.TryParse(ip_adress, true);
tcp::endpoint ep;
ep.address(adress.GetAddress());
ep.port(port);
//// Check that we don't try to connect to a port we're listening on. Doing
//// that could start evil loops.
//tcp::endpoint endpoint = *endpoint_iterator;
if (LocalIPAddresses::Instance()->IsLocalPort(ep.address(), remote_port_))
{
String sMessage;
sMessage.Format(_T("Could not connect to %s on port %d since this would mean connecting to myself."), remote_ip_address_.c_str(), remote_port_);
OnCouldNotConnect(sMessage);
LOG_TCPIP(_T("TCPConnection - ") + sMessage);
return;
}
// Attempt a connection to the first endpoint in the list. Each endpoint
// will be tried until we successfully establish a connection.
socket_.async_connect(ep,
std::bind(&TCPConnection::AsyncConnectCompleted, shared_from_this(), std::placeholders::_1));
}
bool
IPAddress::operator == ( const IPAddress & rhs ) const
{
if ( ( this->GetPort() == rhs.GetPort() ) && ( this->GetAddress() == rhs.GetAddress() ) )
{
return ( true );
}
return ( false );
}
bool
TCPConnection::Connect(const AnsiString &remote_ip_address, long remotePort, const IPAddress &localAddress)
{
#if _DEBUG
if (!StringParser::IsValidIPAddress(remote_ip_address))
{
ErrorManager::Instance()->ReportError(ErrorManager::High, 5506, "TCPConnection::Connect",
Formatter::Format("Attempting to connect to {0} - Not a valid IP address.", remote_ip_address));
}
#endif
remote_port_ = remotePort;
remote_ip_address_ = remote_ip_address;
is_client_ = true;
LOG_TCPIP(Formatter::Format("Connecting to {0}:{1}...", remote_ip_address_, remotePort));
if (!localAddress.IsAny())
{
boost::system::error_code error_code;
if (localAddress.GetType() == IPAddress::IPV4)
socket_.open(boost::asio::ip::tcp::v4(), error_code);
else if (localAddress.GetType() == IPAddress::IPV6)
socket_.open(boost::asio::ip::tcp::v6(), error_code);
if (error_code)
{
String errorMessage = Formatter::Format("Failed to open local socket on IP address {0}", localAddress.ToString());
OnCouldNotConnect(errorMessage);
ReportError(ErrorManager::Medium, 5520, "TCPConnection::Connect", errorMessage, error_code);
return false;
}
socket_.bind(boost::asio::ip::tcp::endpoint(localAddress.GetAddress(), 0), error_code);
if (error_code)
{
String errorMessage = Formatter::Format("Failed to bind to IP address {0}.", localAddress.ToString());
ReportError(ErrorManager::Medium, 4330, "TCPConnection::Connect", errorMessage, error_code);
OnCouldNotConnect(errorMessage);
boost::system::error_code ignored_error_code;
socket_.close(ignored_error_code);
return false;
}
}
// Start an asynchronous resolve to translate the server and service names
// into a list of endpoints.
StartAsyncConnect_(remote_ip_address, remotePort);
return true;
}
bool
TestConnect::PerformTest(const String &localAddressStr, const String &server, int port, String &result)
{
boost::asio::io_service io_service;
IPAddress localAddress;
if (!localAddressStr.IsEmpty())
{
if (!localAddress.TryParse(localAddressStr, false))
{
result.append(Formatter::Format("ERROR: Unable to parse address {0}.\r\n", localAddressStr));
return false;
}
else
result.append(Formatter::Format("Local address is {0}.\r\n", localAddress.ToString()));
}
result.append(Formatter::Format("Trying to connect to host {0}...\r\n", server));
// Get a list of endpoints corresponding to the server name.
tcp::resolver resolver(io_service);
tcp::resolver::query query(AnsiString(server), AnsiString(StringParser::IntToString(port)), tcp::resolver::query::numeric_service);
boost::system::error_code errorResolve = boost::asio::error::host_not_found;
tcp::resolver::iterator endpoint_iterator = resolver.resolve(query, errorResolve);
tcp::resolver::iterator end;
if (errorResolve || endpoint_iterator == end)
{
// Host was not found.
String formattedString;
formattedString.Format(_T("ERROR: The host name %s could not be resolved.\r\n"), server);
result.append(formattedString);
return false;
}
// Try each endpoint until we successfully establish a connection.
tcp::socket socket(io_service);
boost::system::error_code error = boost::asio::error::host_not_found;
while (error && endpoint_iterator != end)
{
boost::asio::ip::address adr = (*endpoint_iterator).endpoint().address();
String ipAddressString = adr.to_string();
String formattedString;
formattedString.Format(_T("Trying to connect to TCP/IP address %s on port %d.\r\n"), ipAddressString, port);
result.append(formattedString);
socket.close();
IPAddress emptyAddr;
bool any = emptyAddr.IsAny();
if (!localAddress.IsAny())
{
socket.open(boost::asio::ip::tcp::v4());
boost::system::error_code tempError;
socket.bind(boost::asio::ip::tcp::endpoint(localAddress.GetAddress(), 0), tempError);
if (tempError)
{
result.append(Formatter::Format("ERROR: Unable to bind to address {0}.\r\n", localAddress.ToString()));
socket.close();
return false;
}
}
socket.connect(*endpoint_iterator++, error);
}
if (error)
{
// We were unable to connect.
result.append(_T("ERROR: It was not possible to connect.\r\n"));
return false;
}
// Read the response status line.
boost::asio::streambuf response;
boost::asio::read_until(socket, response, "\r\n");
std::string s;
std::istream is(&response);
std::getline(is, s, '\r');
result.append(Formatter::Format("Received: {0}.\r\n", String(s)));
// Close the socket again.
socket.close();
result.append(_T("Connected successfully.\r\n"));
return true;
}
