CODEWITHSUNDEEP
c++socketsboostboost-asioasyncsocket
BTR Naidu
BTR Naidu

Reputation: 1101

Set timeout for boost socket.connect

I am using boost::asio::connect on a tcp::socket. When all goes fine, the connect returns immediately but on a poor network, the connect times out after a log wait of 15 seconds. I cannot afford to wait that long and so want to reduce the timeout. Unfortunately I have not come across any solution so far.

I see solutions where async_wait is been used together with deadline_timer but all those examples are for receive / send operations and not for connect.

Can anyone help me with a sample code for boost::asio::connect(socket, endpoints);. Requirement is that it should timeout in 5 seconds instead of 15.

Upvotes: 5

Views: 17543

Answers (2)

Bil_Bomba
Bil_Bomba

Reputation: 181

I know there is already an acceted answer. I found an other solution, which may be usefull for others:

boost::asio::io_service ios;
boost::asio::ip::tcp::endpoint endpoint(remoteAddress);
boost::asio::ip::tcp::socket socket(ios);
boost::system::error_code ec;

auto connectFuture=std::async(std::launch::async,
        [this, &socket, &endpoint]() {
            boost::system::error_code connectEc;
            socket.connect(endpoint, connectEc);
    });

auto timeoutResult=connectFuture.wait_for(std::chrono::milliseconds{timeout});
if( timeoutResult==std::future_status::timeout ) {
 // timeout occured
}

Upvotes: -1

rkachach
rkachach

Reputation: 17325

Have you take a look to the following example? It contains a sample code an async_connect with timeout.

The connect with timeout method could be implemented using the following code:

void connect(const std::string& host, const std::string& service,
  boost::posix_time::time_duration timeout)  {
// Resolve the host name and service to a list of endpoints.
tcp::resolver::query query(host, service);
tcp::resolver::iterator iter = tcp::resolver(io_service_).resolve(query);

// Set a deadline for the asynchronous operation. As a host name may
// resolve to multiple endpoints, this function uses the composed operation
// async_connect. The deadline applies to the entire operation, rather than
// individual connection attempts.
deadline_.expires_from_now(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_connect(socket_, iter, var(ec) = _1);

// Block until the asynchronous operation has completed.
do io_service_.run_one(); while (ec == boost::asio::error::would_block);

// Determine whether a connection was successfully established. The
// deadline actor may have had a chance to run and close our socket, even
// though the connect operation notionally succeeded. Therefore we must
// check whether the socket is still open before deciding if we succeeded
// or failed.
if (ec || !socket_.is_open())
  throw boost::system::system_error(
      ec ? ec : boost::asio::error::operation_aborted);
}

Upvotes: 7

Related Questions