Websocket client in C++ using boost::Beast - throwing error at write operation

Question

Below is a piece of code which I am trying hard to make it successful. I use the reference code available at git hub https://www.boost.org/doc/libs/1_70_0/libs/beast/doc/html/beast/quick_start/websocket_client.html. The problem is when I call the connect method and do write operation in same function it works, however it wont work if I put that in different function.

I am new to boost and shared_pointer, please excuse if I am not making any sense.

    // Sends a WebSocket message and prints the response
    class CWebSocket_Sync : public std::enable_shared_from_this<CWebSocket_Sync>
    {
        tcp::resolver resolver_;
        websocket::stream<tcp::socket> ws_;
        boost::beast::multi_buffer buffer_;
        std::string host_;
        std::string text_;

    public:
        // Resolver and socket require an io_context
        explicit
            CWebSocket_Sync(boost::asio::io_context& ioc)
            : resolver_(ioc)
            , ws_(ioc)
        {
        }

        void 
            connect(
                char const* host,
                char const* port,
                char const* text)
        {
            // Save these for later
            host_ = host;
            text_ = text;

            // Look up the domain name
            auto const results = resolver_.resolve(host, port);

            // Make the connection on the IP address we get from a lookup
            auto ep = net::connect(ws_.next_layer(), results);

            // Update the host_ string. This will provide the value of the
            // Host HTTP header during the WebSocket handshake.
            // See https://tools.ietf.org/html/rfc7230#section-5.4
            host_ += ':' + std::to_string(ep.port());

            // Perform the websocket handshake
            ws_.handshake(host_, "/");

            //ws_.write(net::buffer(std::string(text)));
            //// This buffer will hold the incoming message
            //beast::flat_buffer buffer;

            //// Read a message into our buffer
            //ws_.read(buffer);


        }

        void ServerCommand(char const* text)
        {
            ws_.write(net::buffer(std::string(text)));   // <-- this line throw memory error 

            // This buffer will hold the incoming message
            beast::flat_buffer buffer;

            // Read a message into our buffer
            ws_.read(buffer);


            // The make_printable() function helps print a ConstBufferSequence
            std::cout << beast::make_printable(buffer.data()) << std::endl;
        }

        void CloseConnection()
        {
            // Close the WebSocket connection
            ws_.close(websocket::close_code::normal);
        }

    };
int main(int argc, char** argv)
{
    auto const host = "127.0.0.1";
    auto const port = "7011";
    auto const loginCmd = "login"
    boost::asio::io_context ioc;

    std::make_shared<CWebSocket_Sync>(ioc)->connect(host, port, loginCmd);

    std::make_shared<CWebSocket_Sync>(ioc)->ServerCommand(loginCmd);

    std::make_shared<CWebSocket_Sync>(ioc)->CloseConnection();

    return EXIT_SUCCESS;
}

Answer 1

std::make_shared<CWebSocket_Sync>(ioc)->connect(host, port);
std::make_shared<CWebSocket_Sync>(ioc)->ServerCommand(loginCmd);
std::make_shared<CWebSocket_Sync>(ioc)->CloseConnection();

Each line creates a new client (make_shared<CWebSocket_Sync>) and runs a single step on it. What you probably wanted:

auto client = std::make_shared<CWebSocket_Sync>(ioc);
client->connect(host, port);
client->ServerCommand(loginCmd);
client->CloseConnection();

Indeed this works:

#include <boost/beast.hpp>
#include <boost/beast/websocket.hpp>
#include <memory>
#include <iostream>

namespace net       = boost::asio;
namespace beast     = boost::beast;
namespace websocket = beast::websocket;
using net::ip::tcp;

// Sends a WebSocket message and prints the response
class CWebSocket_Sync : public std::enable_shared_from_this<CWebSocket_Sync> {
    tcp::resolver resolver_;
    websocket::stream<tcp::socket> ws_;
    boost::beast::multi_buffer buffer_;
    std::string host_;

public:
    // Resolver and socket require an io_context
    explicit CWebSocket_Sync(boost::asio::io_context& ioc)
        : resolver_(ioc), ws_(ioc) { }

    void connect(char const* host, char const* port) {
        // Save these for later
        host_ = host;

        // Look up the domain name
        auto const results = resolver_.resolve(host, port);

        // Make the connection on the IP address we get from a lookup
        auto ep = net::connect(ws_.next_layer(), results);

        // Update the host_ string. This will provide the value of the
        // Host HTTP header during the WebSocket handshake.
        // See https://tools.ietf.org/html/rfc7230#section-5.4
        host_ += ':' + std::to_string(ep.port());

        // Perform the websocket handshake
        ws_.handshake(host_, "/");
    }

    void ServerCommand(char const* text) {
        ws_.write(net::buffer(std::string(text)));   // <-- this line throw memory error 

        beast::flat_buffer buffer;
        ws_.read(buffer);

        std::cout << beast::make_printable(buffer.data()) << std::endl;
    }

    void CloseConnection() {
        ws_.close(websocket::close_code::normal);
    }
};

int main() {
    auto const host = "127.0.0.1";
    auto const port = "7011";
    auto const loginCmd = "login";
    boost::asio::io_context ioc;

    auto client = std::make_shared<CWebSocket_Sync>(ioc);
    client->connect(host, port);
    client->ServerCommand(loginCmd);
    client->CloseConnection();
}

SIMPLIFY

However, since nothing uses the shared lifetime and you're not using asynchronous calls anywhere, why not simply:

Live On Coliru

class CWebSocket_Sync {

and later:

    CWebSocket_Sync client(ioc);
    client.connect(host, port);
    client.ServerCommand(loginCmd);
    client.CloseConnection();