https/examples/client_ws_coro.cpp at main · pfeatherstone/https · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
#include <chrono>
#include <boost/compat/bind_front.hpp>
#include <boost/asio/cancel_after.hpp>
#include <boost/asio/connect.hpp>
#include <boost/asio/detached.hpp>
#include <boost/asio/io_context.hpp>
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/spawn.hpp>
#include <boost/asio/ssl/context.hpp>
#include <boost/asio/ssl/stream.hpp>
#include <boost/asio/strand.hpp>
#include <boost/asio/version.hpp>
#include <http_async.h>
#include "extra/CLI11.hpp"

//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------
// Typedefs
//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------

using boost::compat::bind_front;
using boost::asio::detached;
using boost::asio::ip::tcp;
using boost::asio::make_strand;
using tcp_socket            = boost::asio::basic_stream_socket<tcp, boost::asio::strand<boost::asio::io_context::executor_type>>;
using tls_socket            = boost::asio::ssl::stream<tcp_socket>;
using http_socket           = http::stream<tcp_socket>;
using https_socket          = http::stream<tls_socket>;
using yield_context_strand  = boost::asio::basic_yield_context<boost::asio::strand<boost::asio::io_context::executor_type>>;
using namespace std::chrono_literals;

//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------
// WS session
//----------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------

template<class Sock>
void read_write_one(Sock& sock, std::string_view host, std::string& msg, yield_context_strand yield)
{
    constexpr bool is_text{false};
    http::async_ws_handshake(sock, host, "/ws", yield);
    http::async_ws_write(sock, boost::asio::buffer(msg), is_text, yield);
    http::async_ws_read(sock, msg, yield);
    http::async_ws_close(sock, http::ws_going_away, yield);
}

void ws_session(std::string_view host, uint16_t port, std::string_view msg, yield_context_strand yield)
{
    try
    {
        // Objects
        http_socket     sock(tcp_socket(yield.get_executor()), false);
        tcp::resolver   resolver(sock.get_executor());
        std::string     buf(msg);

        // Async IO
        boost::asio::async_connect(sock.lowest_layer(), resolver.async_resolve(host, std::to_string(port), yield), boost::asio::cancel_after(5s, yield));
        read_write_one(sock, host, buf, yield);

        // Print echo
        printf("Server echoed back\n\"%.*s\"\n", (int)buf.size(), buf.data());
    }
    catch(const boost::system::system_error& e)
    {
        if (e.code() != boost::asio::error::eof)
            fprintf(stderr, "[HTTP session] %s\n", e.what());
    }
}

void ws_ssl_session(std::string_view host, uint16_t port, std::string_view msg, yield_context_strand yield)
{
    try
    {
        // Objects
        boost::asio::ssl::context ssl(boost::asio::ssl::context::tlsv12_client);
        ssl.set_verify_callback([](bool preverified, boost::asio::ssl::verify_context& ctx) {return true;});
        ssl.set_verify_mode(boost::asio::ssl::verify_peer);

        https_socket    sock(tls_socket(yield.get_executor(), ssl), false);
        tcp::resolver   resolver(sock.get_executor());
        std::string     buf(msg);

        // Async IO
        boost::asio::async_connect(sock.lowest_layer(), resolver.async_resolve(host, std::to_string(port), yield), boost::asio::cancel_after(5s, yield));
        sock.next_layer().async_handshake(boost::asio::ssl::stream_base::client, yield);
        read_write_one(sock, host, buf, yield);
        sock.next_layer().async_shutdown(yield);

        // Print echo
        printf("TLS server echoed back\n\"%.*s\"\n", (int)buf.size(), buf.data());
    }
    catch(const boost::system::system_error& e)
    {
        if (e.code() != boost::asio::error::eof)
            fprintf(stderr, "[HTTP session] %s\n", e.what());
    }
}

int main(int argc, char* argv[])
{
    std::string host;
    uint16_t    port;
    std::string msg;
    bool        use_tls{};
    CLI::App app{"WebSocket echo client"};
    try{
        app.add_option("--host", host, "Host or IP address of WebSocket server")->required();
        app.add_option("--port", port, "Port of WebSocket server")->required();
        app.add_option("--msg",  msg,  "Message to be echoed back by server")->required();
        app.add_flag("--tls", use_tls, "Use transport over TLS");
        app.parse(argc, argv);
    } catch (const CLI::ParseError& e) {return app.exit(e);}

    boost::asio::io_context ioc{1};

    try
    {
        if (use_tls)
            boost::asio::spawn(make_strand(ioc), bind_front(ws_ssl_session, host, port, msg), detached);
        else
            boost::asio::spawn(make_strand(ioc), bind_front(ws_session, host, port, msg), detached);
        ioc.run();
    }
    catch (const std::exception& e)
    {
        printf("Exception: %s\n", e.what());
    }
}