ASIO (Boost) SSL Network Transfer - c++

Question

I have this piece of code that I've put together from various Boost sources to try and create something that will connect to a host and download the root page/file via SSL. The program runs but returns an empty reply. Could someone suggest why this is the case and suggest an improvement? Link with -l pthread -l ssl -l crypto.
//
// client.cpp
// ~~~~~~~~~~
//
// Copyright (c) 2003-2015 Christopher M. Kohlhoff (chris at kohlhoff dot com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
#include <iostream>
#include <asio.hpp>
#include <asio/ssl.hpp>
#include <functional>
static const char *HOSTNAME { "google.com" };
static const char *HOSTPORT { "https" };
std::string file { "/" };
std::string request {
"GET " + file + " "
+ "HTTP/1.1\r\nHost: " + std::string(HOSTNAME) + "\r\n\r\n" };
enum { max_length = 1024 };
class Client
{
asio::ssl::stream<asio::ip::tcp::socket> ssock;
char reply[max_length];
std::size_t bytes_transferred;
std::error_code ec;
public:
Client(asio::io_service &io_service, asio::ssl::context &context, asio::ip::tcp::resolver::iterator endpoint_iterator) :
ssock(io_service, context)
{
auto handle_connect { std::bind(&Client::handle_handshake, this, ec) };
asio::async_connect(ssock.lowest_layer(), endpoint_iterator, handle_connect);
}
void handle_connect(const std::error_code &ec)
{
if (!ec)
{
auto handle_handshake { std::bind(&Client::handle_handshake, this, ec) };
ssock.async_handshake(asio::ssl::stream_base::client, handle_handshake);
}
else std::cout << "Connect failed: " << ec.message() << "\n";
}
void handle_handshake(const std::error_code &ec)
{
if (!ec)
{
std::cout << request << std::endl;
auto handle_write { std::bind(&Client::handle_write, this, ec, bytes_transferred) };
asio::async_write(ssock, asio::buffer(request), handle_write);
}
else std::cout << "Handshake failed: " << ec.message() << "\n";
}
void handle_write(const std::error_code &ec, std::size_t bytes_transferred)
{
if (!ec)
{
auto handle_read { std::bind(&Client::handle_read, this, ec, bytes_transferred) };
asio::async_read(ssock, asio::buffer(reply, bytes_transferred), handle_read);
}
else std::cout << "Write failed: " << ec.message() << "\n";
}
void handle_read(const std::error_code &ec, std::size_t bytes_transferred)
{
if (!ec)
{
std::cout << "Reply: ";
std::cout.write(reply, bytes_transferred);
std::cout << "\n";
}
else std::cout << "Read failed: " << ec.message() << "\n";
}
};
int main(int argc, char* argv[])
{
try
{
asio::io_service io_service;
asio::ip::tcp::resolver resolver(io_service);
asio::ip::tcp::resolver::query query(HOSTNAME, HOSTPORT);
asio::ip::tcp::resolver::iterator iterator = resolver.resolve(query);
asio::ssl::context ctx(asio::ssl::context::sslv23);
Client client(io_service, ctx, iterator);
io_service.run();
}
catch (std::exception& e)
{
std::cerr << "Exception: " << e.what() << "\n";
}
return 0;
}
I think the problem is with these callbacks. The operations within the callbacks themselves are correct as they're taken straight from the example. Is there a better way to rewrite by using Lambdas for callbacks? I don't like the way these callbacks are bound by bind.

Answer 1

auto handle_connect { std::bind(&Client::handle_handshake, this, ec) };
in the constructor should be:
auto handle_connect { std::bind(&Client::handle_connect, this, ec) };