Recently I had to add a Websocket server to a C++ project. Some research showed that the options here aren’t too many. There are a few C-based options, and one can of course pick the Websocket module from the POCO libraries [1] if one desires a C++ approach. Since this particular project is written in C++ I much preferred a purely C++ solution, preferably stand-alone. Ultimately I picked the (creatively named) Websocket++ library [2], also referred to as Websocketpp. Main arguments here were as mentioned being an object-oriented C++ solution, without significant dependencies, as well as ease of implementation thanks to it being a header-only library.

Websocket++ is a fairly modular library, making heavy use of templating to assemble various configurations, end points and similar into one coherent whole. As the basis for the transport module can for example pick from iostreams (very slow) and ASIO. For the latter one can pick between Boost ASIO and stand-alone ASIO. There is also the option of using no C++11 features and using the Boost alternatives instead. Since this project involved a number of compile targets, not all of which featured a C++11-capable compiler, the final configuration involved a Boost dependency using its ASIO and system library, as well as various other header-only dependencies.

After starting the actual integration of the library into my project, I did however find out that the quality of the documentation is very… sub-optimal. The documentation is split between the GitHub site and the author’s own site, with most of this documentation being completely and utterly outdated. Only after significant amounts of trial and error did I manage to get a fully working implementation. To save others the trouble, I would like to hereby present a (simplified and altered) version of my implementation. I hope it will be useful.

Let’s move on to the header file of our implementation:

#include "websocketpp/server.hpp" #include "websocketpp/config/asio_no_tls.hpp"

With these two includes we pick from the Websocket++ server role and make available the ASIO configuration without TLS feature, meaning no encrypted connections.

class WebsocketServer { public: static bool init(); static void run(); static void stop(); static bool sendClose(string id); static bool sendData(string id, string data); private: static bool getWebsocket(const string &id, websocketpp::connection_hdl &hdl); static websocketpp::server<websocketpp::config::asio> server; static pthread_rwlock_t websocketsLock; static map<string, websocketpp::connection_hdl> websockets; static LogStream ls; static ostream os; // callbacks static bool on_validate(websocketpp::connection_hdl hdl); static void on_fail(websocketpp::connection_hdl hdl); static void on_close(websocketpp::connection_hdl hdl); };

Our class definition implements a static class. This will allow us to use the Websocket functionality from multiple classes. Websocket++ is thread-safe, so all we have to worry about is multi-thread level access to our own data structures and variables.

Moving on to the implementation, we can see first the usual static initialisations and namespace merging:

// static initialisations websocketpp::server<websocketpp::config::asio> WebsocketServer::server; map<string, connection_hdl> WebsocketServer::websockets; pthread_rwlock_t WebsocketServer::websocketsLock = PTHREAD_RWLOCK_INITIALIZER; LogStream WebsocketServer::ls; ostream WebsocketServer::os(&ls); // namespace merging using websocketpp::connection_hdl;

Next is initialising the library and the server instance:

bool WebsocketServer::init() { // Initialising WebsocketServer. server.init_asio();

When using the ASIO transport option, we call its init method here.

// Set custom logger (ostream-based). server.get_alog().set_ostream(&os); server.get_elog().set_ostream(&os);

We may want to redirect the logging output to our own logging method. Websocket++’s basic logger allows us to set an ostream alternative for the standard std::cout and std::cerr. We will look at this in more detail later on.

// Register the message handlers. server.set_validate_handler(&WebsocketServer::on_validate); server.set_fail_handler(&WebsocketServer::on_fail); server.set_close_handler(&WebsocketServer::on_close);

Next we set the message handlers. These are all callback methods we will define in a moment.

// Listen on port. int port = 8082; try { server.listen(port); } catch(websocketpp::exception const &e) { // Websocket exception on listen. Get char string via e.what(). }

With all the configuration done, we can start listening using the transport framework, this is done with the listen() call on the server object. This method is not exception-free, so we surround it with a try/catch block.

// Starting Websocket accept. websocketpp::lib::error_code ec; server.start_accept(ec); if (ec) { // Can log an error message with the contents of ec.message() here. return false; } return true; }

Finally we start accepting connections. We just need to start the server proper now, which is done in the following function:

void WebsocketServer::run() { try { server.run(); } catch(websocketpp::exception const &e) { // Websocket exception. Get message via e.what(). } }

Again, this is another method which isn’t exception-free, so we have to surround it with a try/catch block. The other clue here is that when we shut down the server at some point, we have to wait for this (blocking) run() call to return before we for example terminate a thread.

void WebsocketServer::stop() { // Stopping the Websocket listener and closing outstanding connections. websocketpp::lib::error_code ec; server.stop_listening(ec); if (ec) { // Failed to stop listening. Log reason using ec.message(). return; } // Close all existing websocket connections. string data = "Terminating connection..."; map<string, connection_hdl>::iterator it; for (it = websockets.begin(); it != websockets.end(); ++it) { websocketpp::lib::error_code ec; server.close(it->second, websocketpp::close::status::normal, data, ec); // send text message. if (ec) { // we got an error // Error closing websocket. Log reason using ec.message(). } } // Stop the endpoint. server.stop(); }

Shutting down the Websocket server is fairly obvious: first we stop listening. This means we will no longer accept new connections. Next we go through all of the websocket connections we still have and close every single one of them. Finally we call stop() on the server object. This isn’t strictly necessary, but it will ensure that the transport backend is completely shut down and any remaining connections forcefully terminated.

Let’s move on to actually accepting new connections. For this we can use a number of handlers [3], including open() and validate. I picked the validate handler, since it allows one to filter incoming connections and reject any which do not authenticate properly or such:

bool WebsocketServer::on_validate(connection_hdl hdl) { websocketpp::server<websocketpp::config::asio>::connection_ptr con = server.get_con_from_hdl(hdl); websocketpp::uri_ptr uri = con->get_uri(); string query = uri->get_query(); // returns empty string if no query string set. if (!query.empty()) { // Split the query parameter string here, if desired. // We assume we extracted a string called 'id' here. } else { // Reject if no query parameter provided, for example. return false; } if (pthread_rwlock_wrlock(&websocketsLock) != 0) { // Failed to write-lock websocketsLock. } websockets.insert(std::pair<string, connection_hdl>(id, hdl)); if (pthread_rwlock_unlock(&websocketsLock) != 0) { // Failed to unlock websocketsLock. } return true; }

This code shows how to obtain the connection behind a connection handle from Websocket++ and to extract the URI including its query parameter string from it.

Here we assume that the connection client has to provide a string-based ID, though one can also use another identifier, based on the implementation. We use pthread-based locking around the websockets map to ensure no concurrent access takes place on this data structure and insert the new websocket handle with its id as key.

We may also wish to implement the fail() and close() handlers:

void WebsocketServer::on_fail(connection_hdl hdl) { websocketpp::server<websocketpp::config::asio>::connection_ptr con = server.get_con_from_hdl(hdl); websocketpp::lib::error_code ec = con->get_ec(); // Websocket connection attempt by client failed. Log reason using ec.message(). } void WebsocketServer::on_close(connection_hdl hdl) { // Websocket connection closed. }

For the fail handler, we can obtain the connection as before, and extract the error code object to learn the reason behind the failure.

The close handler should generally be fairly boring, but it can be informative to have the confirmation in a log or such of a successfully closed connection.

Moving on, we just have to look at how to send data to such a socket.

bool WebsocketServer::sendData(string id, string data) { connection_hdl hdl; if (!getWebsocket(id, hdl)) { // Sending to non-existing websocket failed. return false; } websocketpp::lib::error_code ec; server.send(hdl, data, websocketpp::frame::opcode::text, ec); // send text message. if (ec) { // we got an error // Error sending on websocket. Log reason using ec.message(). return false; } return true; }

This function obtains the appropriate connection handle based upon the ID, then proceeds to write the provided data to this connection. The getWebsocket() method is a trivial STL map-based find and iteration effort and isn’t further documented here. Do not forget to lock the map while performing said find and iterator actions on it.

Lastly, how to close a socket:

bool WebsocketServer::sendClose(string id) { connection_hdl hdl; if (!getWebsocket(id, hdl)) { // Closing non-existing websocket failed. return false; } string data = "Terminating connection..."; websocketpp::lib::error_code ec; server.close(hdl, websocketpp::close::status::normal, data, ec); // send close message. if (ec) { // we got an error // Error closing websocket. Log reason using ec.message(). return false; } // Remove websocket from the map. pthread_rwlock_rdlock(&websocketsLock); websockets.erase(id); pthread_rwlock_unlock(&websocketsLock); return true; }

Here we again obtain the proper connection handle, only this time we use the ‘close’ method instead of ‘send’. We can send a close reason using a string, or just send an empty string.

Finally the ID is erased from the websockets map and the now invalid connection handle with it.

With this we have everything we need for the Websocket server, except for one thing: the redirecting of the logging output from Websocket++. We saw earlier that we use the set_ostream() method on the logging interfaces. In the class declaration we saw this mysterious ‘LogStream’ type and an ostream, and again in the static initialisations.

What happens here is that this LogStream class is a custom implementation of std::streambuf, assigned to an std::ostream object which then replaces the standard outputs Websocket++’s logging. For the actual streambuf implementation, one would use something like this:

class LogStream : public streambuf { private: string buffer; protected: int overflow(int ch) override { buffer.push_back((char) ch); if (ch == '

') { // End of line, write to logging output and clear buffer. buffer.clear(); } return ch; // Return traits::eof() for failure. } };

We just override the virtual overflow() method in the streambuf class. In the default implementation the default buffer overflows for every character written to the streambuf class and thus our overflow method is called for each character.

Using a string as buffer, we capture each received character and check whether it is a newline character or not. If it is we have a complete line which we can then write to whatever logging functionality we use in our project. After this we empty the buffer string and continue with the new line.

In conclusion, I must say that despite the effort it cost me to get a working integration of Websocket++ in my project, I do think it was worth it. Technically it is a well-designed library with a lot of cool features and thanks to its template-based nature ease of expansion and configuration to fit different purposes. Its main weakness is simply the outdated, lacking and occasionally wrong documentation and examples. Hopefully this article will fix at least part of that problem 🙂

Maya

[1] http://pocoproject.org/

[2] https://github.com/zaphoyd/websocketpp

[3] http://www.zaphoyd.com/websocketpp/manual/reference/handler-list