I am using Websocketpp to create a client program. I was mostly following the tutorial that zaphoyd has on the website, but since it does not include a TLS client, I did some digging around and changed up a few things to get my TLS client:
#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <sstream>
#include <websocketpp/config/asio_client.hpp>
#include <boost/asio.hpp>
#include <boost/asio/ssl.hpp>
#include <boost/asio/ssl/context.hpp>
#include <websocketpp/client.hpp>
#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/memory.hpp>
typedef websocketpp::client<websocketpp::config::asio_tls_client> client;
class connection_metadata {
private:
int m_id;
websocketpp::connection_hdl m_hdl;
std::string m_status;
std::string m_uri;
std::string m_server;
std::string m_error_reason;
public:
typedef websocketpp::lib::shared_ptr<connection_metadata> ptr;
connection_metadata(int id, websocketpp::connection_hdl hdl, std::string uri):
m_id(id),
m_hdl(hdl),
m_status("Connecting"),
m_uri(uri),
m_server("N/A")
{}
int get_id(){return m_id;}
websocketpp::connection_hdl get_hdl(){ return m_hdl;}
std::string get_status(){return m_status;}
void on_open(client * c, websocketpp::connection_hdl hdl){
m_status = "Open";
client::connection_ptr con = c->get_con_from_hdl(hdl);
m_server = con->get_response_header("Server");
}
void on_fail(client * c, websocketpp::connection_hdl hdl){
m_status = "Failed";
client::connection_ptr con = c->get_con_from_hdl(hdl);
m_server = con->get_response_header("Server");
m_error_reason = con->get_ec().message();
}
void on_close(client * c, websocketpp::connection_hdl hdl){
m_status = "Closed";
client::connection_ptr con = c->get_con_from_hdl(hdl);
std::stringstream s;
s << "Close code: " << con->get_remote_close_code() << "("
<< websocketpp::close::status::get_string(con->get_remote_close_code())
<< "), Close reason: " << con->get_remote_close_reason();
m_error_reason = s.str();
}
friend std::ostream &operator<< (std::ostream &out, connection_metadata const &data);
};
std::ostream &operator<< (std::ostream &out, connection_metadata const &data){
out << "> URI: " << data.m_uri << "\n"
<< "> Status: " << data.m_status << "\n"
<< "> Remote Server: " << (data.m_server.empty() ? "None Specified" : data.m_server) << "\n"
<< "> Error/close reason: " << (data.m_error_reason.empty() ? "N/A" : data.m_error_reason);
return out;
}
class websocket_endpoint {
private:
typedef std::map<int,connection_metadata::ptr> con_list;
client m_endpoint;
websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
con_list m_connection_list;
int m_next_id;
public:
websocket_endpoint(): m_next_id(0) {
m_endpoint.set_access_channels(websocketpp::log::alevel::all);
m_endpoint.set_error_channels(websocketpp::log::elevel::all);
m_endpoint.init_asio();
m_endpoint.start_perpetual();
m_thread.reset(new websocketpp::lib::thread(&client::run, &m_endpoint));
}
~websocket_endpoint() {
m_endpoint.stop_perpetual();
for (con_list::const_iterator it = m_connection_list.begin(); it != m_connection_list.end(); ++it) {
if (it->second->get_status() != "Open") {
continue;
}
std::cout << "> Closing connection " << it->second->get_id() << std::endl;
websocketpp::lib::error_code ec;
m_endpoint.close(it->second->get_hdl(), websocketpp::close::status::going_away, "", ec);
if (ec) {
std::cout << "> Error closing connection " << it->second->get_id() << ": "
<< ec.message() << std::endl;
}
}
m_thread->join();
}
int connect (std::string const &uri) {
websocketpp::lib::error_code ec;
client::connection_ptr con = m_endpoint.get_connection(uri, ec);
if(ec){
std::cout << "Connection initialization error: " << ec.message() << std::endl;
return -1;
}
int new_id = m_next_id++;
connection_metadata::ptr metadata_ptr(new connection_metadata(new_id, con->get_handle(), uri));
m_connection_list[new_id] = metadata_ptr;
con->set_open_handler(websocketpp::lib::bind(
&connection_metadata::on_open,
metadata_ptr,
&m_endpoint,
websocketpp::lib::placeholders::_1
));
con->set_fail_handler(websocketpp::lib::bind(
&connection_metadata::on_fail,
metadata_ptr,
&m_endpoint,
websocketpp::lib::placeholders::_1
));
con->set_close_handler(websocketpp::lib::bind(
&connection_metadata::on_close,
metadata_ptr,
&m_endpoint,
websocketpp::lib::placeholders::_1
));
con->set_tls_init_handler([](websocketpp::connection_hdl){
boost::asio::ssl::context context(boost::asio::ssl::context::tlsv1);
return websocketpp::lib::make_shared<boost::asio::ssl::context>(std::move(context));
});
m_endpoint.connect(con);
return new_id;
}
connection_metadata::ptr get_metadata(int id) const {
con_list::const_iterator metadata_it = m_connection_list.find(id);
if (metadata_it == m_connection_list.end()) {
return connection_metadata::ptr();
} else {
return metadata_it->second;
}
}
void close(int id, websocketpp::close::status::value code, std::string reason) {
websocketpp::lib::error_code ec;
con_list::iterator metadata_it = m_connection_list.find(id);
if (metadata_it == m_connection_list.end()) {
std::cout << "> No connection found with id " << id << std::endl;
return;
}
m_endpoint.close(metadata_it->second->get_hdl(), code, "", ec);
std::cout << "Connection closed with reason: " << reason << std::endl;
}
};
int main(){
bool done = false;
std::string input;
websocket_endpoint endpoint;
while(!done) {
std::cout << "Enter Command: ";
std::getline(std::cin, input);
if(input == "quit"){
done = true;
}
else if(input == "help"){
std::cout << "\nCommand List:\n"
<< "help: Displays this help text\n"
<< "quit: exits the program\n"
<< "connect <URI>: creates a connection with the given URI\n"
<< "close <id> <code (optional)> <reason (optional)>: closes the connection with the given id with optionally specifiable exit_code and/or reason\n"
<< "show <id>: Gets the metadata of the connection with the given id\n"
<< std::endl;
}
else if (input.substr(0,7) == "connect") {
int id = endpoint.connect(input.substr(8));
if (id != -1) {
std::cout << "> Created connection with id " << id << std::endl;
}
}
else if (input.substr(0,4) == "show") {
int id = atoi(input.substr(5).c_str());
connection_metadata::ptr metadata = endpoint.get_metadata(id);
if (metadata) {
std::cout << *metadata << std::endl;
} else {
std::cout << "> Unknown connection id " << id << std::endl;
}
}
else if(input.substr(0, 5) == "close"){
std::stringstream ss(input);
std::string cmd;
int id;
int close_code = websocketpp::close::status::normal;
std::string reason;
ss >> cmd >> id >> close_code;
std::getline(ss, reason);
endpoint.close(id, close_code, reason);
}
else{
std::cout << "Unrecognized command" << std::endl;
}
}
return 0;
}
However, when I try to connect to websocket servers like wss://echo.websocket.events, I always get the logged error [fatal] Required tls_init handler not present. with a "Connection attempt failed" message.
I tried pushing the handler function into the metadata class, but that runs into some errors with function signatures.
I do have a tls_init_handler in my code. What could be going wrong?
Note: I have OpenSSL installed, and I am building with CMake and have set find_package(OpenSSL REQUIRED). Also, during the build, in the terminal, it shows -- Found OpenSSL: /usr/lib/x86_64-linux-gnu/libcrypto.so (found version "1.1.1f").
The set_tls_init_handler() call should be made on m_endpoint (aka websocketpp::client) before calling m_endpoint.get_connection(), and not on con (aka client::connection_ptr). See this or this example.
So you need to call m_endpoint.set_tls_init_handler() before m_endpoint.get_connection(), and remove the current con->set_tls_init_handler() call.