Segmentation fault in Boost blocking connect function when no server is present? - c++

Question

Boost blocking TCP implementation taken from here:
http://www.boost.org/doc/libs/1_52_0/doc/html/boost_asio/example/timeouts/blocking_tcp_client.cpp
Another similar problem, mentioned here
Boost.Asio segfault, no idea why
I tried checking the destructor order and dependencies as mentioned in the answer but no luck.
Posting relevant code here
edit:: This MSVC code actually works without segmentation fault. Will be updating code with more relevant info from the failing program.
main.cpp
{
int main(void) {
int k = Connection_Init();
return k;
}
}
In Connection_Init(), I am calling c.connect(IP, Host, timeout);
The seg fault occurs while returning from c.connect(), given in Network.cpp
Network.h
{
class client
{
public:
client()
: socket_(io_service_),
deadline_(io_service_)
{
// No deadline is required until the first socket operation is started. We
// set the deadline to positive infinity so that the actor takes no action
// until a specific deadline is set.
deadline_.expires_at(boost::posix_time::pos_infin);
// Start the persistent actor that checks for deadline expiry.
check_deadline();
}
int connect(const std::string& host, const std::string& service, tcp::resolver::query& q1,
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(q1);
// 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()) {
cout << "send_test_case:connect: Connection could not be established to"
<< LWIP_IP << " " << LWIP_PORT << endl;
//throw boost::system::system_error(
//boost::asio::error::operation_aborted);
//ec ? ec : boost::asio::error::operation_aborted);
return -1;
}
return 1;
}
private:
void check_deadline(
boost::asio::io_service io_service_;
//moving to public access
public: tcp::socket socket_;
private: deadline_timer deadline_;
boost::asio::streambuf input_buffer_;
};
}
and Network.cpp
{
client c;
tcp::resolver::query query(LWIP_IP, LWIP_PORT);
int Connection_Init() {
cout << "IP: " << LWIP_IP << "and Port:" << LWIP_PORT << endl;
int status = 1;
try
{
status = c.connect(LWIP_IP, LWIP_PORT, query, boost::posix_time::seconds(POSITIVE_TESTING_CONNECT_TIMEOUT));
}
//connection initialization should never fail
catch(std::exception &e) {
status = -1;
std::cerr << __FUNCTION__ << ": " << "Exception: " << e.what() << "\n";
}
catch(...) {
status = -1;
}
return status;
}
}