WebSocket++

https://github.com/zaphoyd/websocketpp
Admin
WebSocket++ is a header-only C++ library that implements RFC6455 WebSocket Protocol, enabling...
Tokens:29,536
Snippets:205
Trust Score:6.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Build and Run Websocketpp Examples

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/sip_client/README.txt

Configures the project build environment using CMake and compiles the sip_client example using Make. The process requires the project source code and assumes a Unix-like environment with CMake and Make installed.

```bash
cmake -G 'Unix Makefiles' \
   -D BUILD_EXAMPLES=ON \
   -D WEBSOCKETPP_ROOT=/tmp/cm1 \
   -D ENABLE_CPP11=OFF .

make -C examples/sip_client

bin/sip_client ws://ws-server:80
```

--------------------------------

### WebSocket++ Client Endpoint Setup (C++)

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Initializes a WebSocket++ client endpoint using the asio_client configuration for non-TLS connections with Boost.Asio. This involves including necessary headers and defining a typedef for the client endpoint. Requires linking against the boost_system library.

```cpp
#include <websocketpp/client.hpp>
#include <websocketpp/config/asio_no_tls_client.hpp>

// Define a typedef for the client endpoint
typedef websocketpp::client<websocketpp::config::asio_client> client;

// ... rest of the client code ...
```

--------------------------------

### Build Commands for WebSocket++

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Compilation commands for various environments, highlighting the necessary linker flags for Boost and C++11 standard library support.

```bash
# Clang (C++98 & boost)
clang++ step3.cpp -lboost_system -lboost_random -lboost_thread

# Clang (C++11)
clang++ -std=c++0x -stdlib=libc++ step3.cpp -lboost_system -D_WEBSOCKETPP_CPP11_STL_

# G++ (C++98 & Boost)
g++ step3.cpp -lboost_system -lboost_random -lboost_thread

# G++ v4.6+ (C++11)
g++ -std=c++0x step3.cpp -lboost_system -D_WEBSOCKETPP_CPP11_STL_
```

--------------------------------

### Initialize WebSocket++ Client Command Loop

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

A basic C++ structure for a command-line interface that processes user input while preparing for WebSocket client integration.

```cpp
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>
#include <iostream>
#include <string>

typedef websocketpp::client<websocketpp::config::asio_client> client;

int main() {
    bool done = false;
    std::string input;

    while (!done) {
        std::cout << "Enter Command: ";
        std::getline(std::cin, input);

        if (input == "quit") {
            done = true;
        } else if (input == "help") {
            std::cout << "\nCommand List:\nhelp: Display this help text\nquit: Exit the program\n" << std::endl;
        } else {
            std::cout << "Unrecognized Command" << std::endl;
        }
    }
    return 0;
}
```

--------------------------------

### Implement command loop for sending messages

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Parses user input from a command line interface to trigger the send functionality for a specific connection ID.

```cpp
else if (input.substr(0,4) == "send") {
    std::stringstream ss(input);
        
        std::string cmd;
        int id;
        std::string message = "";
        
        ss >> cmd >> id;
        std::getline(ss,message);
        
        endpoint.send(id, message);
}
```

--------------------------------

### Initialize and Run WebSocket++ Server

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_server/utility_server.md

Configures the listening socket, initiates connection acceptance, and starts the Asio event loop. This method blocks the thread to process incoming WebSocket connections and data messages.

```cpp
m_endpoint.listen(9002);
m_endpoint.start_accept();
m_endpoint.run();
```

--------------------------------

### Implement Connect and Show Commands in C++

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

This snippet demonstrates how to parse user input to trigger connection establishment using a URI and how to retrieve and display metadata for a specific connection ID. It relies on a pre-configured endpoint object and a connection_metadata structure.

```cpp
} 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;
    }
}
```

--------------------------------

### Track and display sent messages in metadata

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Adds functionality to the connection_metadata class to store sent messages in a vector and display them using an output operator.

```cpp
void record_sent_message(std::string message) {
    m_messages.push_back(">> " + message);
}

out << "> Messages Processed: (" << data.m_messages.size() << ") \n";

std::vector<std::string>::const_iterator it;
for (it = data.m_messages.begin(); it != data.m_messages.end(); ++it) {
    out << *it << "\n";
}
```

--------------------------------

### Initialize Target and Build Executable (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/telemetry_client/CMakeLists.txt

Initializes a target named 'telemetry_client' and then builds an executable using the discovered source and header files. This is a standard CMake procedure for creating executables.

```cmake
init_target (telemetry_client)

build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
```

--------------------------------

### Process Close Command Input

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Parses user input from a command loop to trigger a connection closure. It accepts an ID, optional close code, and optional reason string.

```cpp
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);
}
```

--------------------------------

### Initialize and Run WebSocket Client in C++

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

This snippet demonstrates the initialization of a WebSocket client using websocketpp. It sets up the ASIO event loop, runs it in a separate thread, and provides a basic command-line interface for user interaction. Dependencies include the websocketpp library and standard C++ libraries.

```cpp
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>

#include <websocketpp/common/thread.hpp> 
#include <websocketpp/common/memory.hpp>

#include <iostream>
#include <string>

typedef websocketpp::client<websocketpp::config::asio_client> client;

class websocket_endpoint {
public:
    websocket_endpoint () {
        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
        m_endpoint.clear_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));
    }
private:
    client m_endpoint;
    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
};

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: Display this help text\n"
                << "quit: Exit the program\n"
                << std::endl;
        } else {
            std::cout << "Unrecognized Command" << std::endl;
        }
    }

    return 0;
}

```

--------------------------------

### Configure WebSocket++ Endpoint and Background Thread

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Configures the WebSocket++ endpoint to run in perpetual mode and launches a background thread to handle network events, ensuring the main thread remains responsive to user input.

```cpp
// Disable logging
m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
m_endpoint.clear_error_channels(websocketpp::log::elevel::all);

// Initialize asio and start perpetual mode
m_endpoint.init_asio();
m_endpoint.start_perpetual();

// Launch background processing thread
m_thread.reset(new websocketpp::lib::thread(&client::run, &m_endpoint));
```

--------------------------------

### Basic C++ Command Loop

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

A fundamental C++ program that creates a loop to prompt the user for commands and process them. It handles 'quit' to exit and 'help' to display available commands. This serves as the foundation for adding WebSocket functionality.

```cpp
#include <iostream>
#include <string>

int main() {
    bool done = false;
    std::string input;

    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: Display this help text\n"
                << "quit: Exit the program\n"
                << std::endl;
        } else {
            std::cout << "Unrecognized Command" << std::endl;
        }
    }

    return 0;
}
```

--------------------------------

### Enable Multiple Access Channels

Source: https://github.com/zaphoyd/websocketpp/blob/master/docs/logging.dox

This example shows how to enable multiple access logging channels simultaneously using bitwise OR operations. This allows for granular control over which events are logged.

```cpp
log::alevel::message_payload | log::alevel::message_payload
```

--------------------------------

### Send WebSocket message via endpoint

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Demonstrates how to look up a connection by ID and send a text message using the WebSocket++ endpoint. It includes error handling and records the sent message in the connection metadata.

```cpp
void send(int id, std::string message) {
    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.send(metadata_it->second->get_hdl(), message, websocketpp::frame::opcode::text, ec);
    if (ec) {
        std::cout << "> Error sending message: " << ec.message() << std::endl;
        return;
    }
    
    metadata_it->second->record_sent_message(message);
}
```

--------------------------------

### Generate Connection ID and Metadata

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

This snippet demonstrates the process of generating a new sequential connection ID, creating a `connection_metadata` object, and storing it in a connection list. The metadata initially holds the connection ID, handle, and the URI.

```cpp
int new_id = m_next_id++;
metadata_ptr metadata(new connection_metadata(new_id, con->get_handle(), uri));
m_connection_list[new_id] = metadata;
```

--------------------------------

### WebSocket Client Implementation in C++ using websocketpp

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

This C++ code implements a basic WebSocket client using the websocketpp library. It defines classes for managing connections and the overall endpoint, handling connection events like 'open' and 'fail', and provides a command-line interface for user interaction. Dependencies include the websocketpp library and standard C++ libraries.

```cpp
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>

#include <websocketpp/common/thread.hpp>
#include <websocketpp/common/memory.hpp>

#include <cstdlib>
#include <iostream>
#include <map>
#include <string>
#include <sstream>

typedef websocketpp::client<websocketpp::config::asio_client> client;

class connection_metadata {
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")
    {}

    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();
    }

    friend std::ostream & operator<< (std::ostream & out, connection_metadata const & data);
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;
};

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 {
public:
    websocket_endpoint () : m_next_id(0) {
        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
        m_endpoint.clear_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));
    }

    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 << "> Connect 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
        ));

        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;
        }
    }
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;
};

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"
                << "connect <ws uri>\n"
                << "show <connection id>\n"
                << "help: Display this help text\n"
                << "quit: Exit the program\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 {
            std::cout << "> Unrecognized Command" << std::endl;
        }
    }

    return 0;
}

```

--------------------------------

### Implement WebSocket Server with Asio Transport

Source: https://context7.com/zaphoyd/websocketpp/llms.txt

This snippet demonstrates how to initialize a WebSocket server using the Asio transport layer. It configures a message handler to echo received payloads back to the client and starts the event loop on a specified port.

```cpp
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
#include <iostream>

typedef websocketpp::server<websocketpp::config::asio> server;
typedef server::message_ptr message_ptr;

void on_message(server* s, websocketpp::connection_hdl hdl, message_ptr msg) {
    std::cout << "Received: " << msg->get_payload() << std::endl;

    try {
        // Echo the message back
        s->send(hdl, msg->get_payload(), msg->get_opcode());
    } catch (websocketpp::exception const & e) {
        std::cout << "Send failed: " << e.what() << std::endl;
    }
}

int main() {
    server echo_server;

    try {
        // Configure logging
        echo_server.set_access_channels(websocketpp::log::alevel::all);
        echo_server.clear_access_channels(websocketpp::log::alevel::frame_payload);

        // Initialize Asio transport
        echo_server.init_asio();

        // Register message handler
        echo_server.set_message_handler(
            websocketpp::lib::bind(&on_message, &echo_server,
                websocketpp::lib::placeholders::_1,
                websocketpp::lib::placeholders::_2)
        );

        // Listen on port 9002
        echo_server.listen(9002);

        // Start accepting connections
        echo_server.start_accept();

        // Run the event loop
        echo_server.run();
    } catch (websocketpp::exception const & e) {
        std::cout << e.what() << std::endl;
    }
}
```

--------------------------------

### Initiate WebSocket Connection Closure

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

A wrapper method for the endpoint close operation. It locates a connection by ID and dispatches an asynchronous close signal to the WebSocket++ endpoint.

```cpp
void close(int id, websocketpp::close::status::value code) {
    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);
    if (ec) {
        std::cout << "> Error initiating close: " << ec.message() << std::endl;
    }
}
```

--------------------------------

### Define a Custom WebSocket++ Server Configuration

Source: https://github.com/zaphoyd/websocketpp/blob/master/docs/config.dox

Demonstrates how to create a custom configuration struct by inheriting from an existing policy and overriding specific types and constants. This example shows how to integrate a syslog logger, adjust buffer sizes, and enable permessage_deflate extensions.

```cpp
#include <websocketpp/logger/syslog.hpp>
#include <websocketpp/extensions/permessage_deflate/enabled.hpp>

struct custom_server_config : public websocketpp::config::asio {
	typedef websocketpp::log::syslog<concurrency_type, websocketpp::log::elevel> elog_type;
	typedef websocketpp::log::syslog<concurrency_type, websocketpp::log::alevel> alog_type;

	static const size_t connection_read_buffer_size = 1024;

    struct permessage_deflate_config {};

    typedef websocketpp::extensions::permessage_deflate::enabled
        <permessage_deflate_config> permessage_deflate_type;
};

typedef websocketpp::server<custom_server_config> server_endpoint_type;
```

--------------------------------

### Configure Build Targets with CMake Macros

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/dev/CMakeLists.txt

This script initializes the build environment by globbing source and header files, defining the target executable, and linking necessary dependencies like Boost. It concludes by setting target properties to organize the output into an examples folder.

```cmake
file (GLOB SOURCE_FILES *.cpp)
file (GLOB HEADER_FILES *.hpp)

#init_target (dev)

#build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})

#link_boost ()
#final_target ()

#set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
```

--------------------------------

### Build Executable (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/iostream_server/CMakeLists.txt

This CMake command defines a target and builds an executable from the specified source and header files. The `${TARGET_NAME}` variable is assumed to be defined elsewhere in the CMakeLists.txt. This is a standard way to create executables in CMake projects.

```cmake
init_target (iostream_server)
build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
```

--------------------------------

### Enable All Access Channels Except One

Source: https://github.com/zaphoyd/websocketpp/blob/master/docs/logging.dox

This example demonstrates how to enable all access logging channels except for a specific one using the bitwise XOR operation. This is useful for excluding certain types of messages from logs.

```cpp
log::alevel::all ^ log::alevel::message_payload
```

--------------------------------

### Setting Target Properties (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/broadcast_server/CMakeLists.txt

This CMake command sets properties for the built target, specifically organizing it into a folder named 'examples'. This helps in managing the build output, especially in larger projects with multiple targets, by grouping related executables or libraries together in the generated build system structure.

```cmake
set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
```

--------------------------------

### Register Connection Open Handler

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

This code registers a connection-specific open handler using `websocketpp::lib::bind`. It binds the `connection_metadata::on_open` member function to the connection's open event, passing the metadata object, endpoint, and a placeholder for the connection handle.

```cpp
con->set_open_handler(websocketpp::lib::bind(
    &connection_metadata::on_open,
    metadata,
    &m_endpoint,
    websocketpp::lib::placeholders::_1
));
```

--------------------------------

### Initialize and Build Executable with OpenSSL Support (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/print_client_tls/CMakeLists.txt

This CMake snippet initializes a build target named 'print_client_tls' and then builds an executable using the discovered source and header files. It conditionally links Boost and OpenSSL libraries, and finalizes the target, setting its folder property to 'examples'.

```cmake
if (OPENSSL_FOUND)

init_target (print_client_tls)

build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})

link_boost ()
link_openssl()
final_target ()

set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")

endif()
```

--------------------------------

### Conditional Build with Zlib Dependency (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/testee_client/CMakeLists.txt

This CMake snippet demonstrates conditional compilation based on whether Zlib is found. If Zlib is available, it proceeds to initialize a target named 'testee_client', build an executable, link necessary libraries (Boost and Zlib), and finalize the target, setting its folder property to 'examples'.

```cmake
if (ZLIB_FOUND)

init_target (testee_client)

build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})

link_boost ()
link_zlib()
final_target ()

set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")

endif()
```

--------------------------------

### C++ WebSocket++ Registering Message Handler

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Demonstrates how to register a message handler with a WebSocket++ connection. This code snippet uses `websocketpp::lib::bind` to associate the `on_message` member function of a `connection_metadata` object with the connection's message handler. It correctly specifies the placeholders for the two required parameters: connection handle and message pointer.

```cpp
con->set_message_handler(websocketpp::lib::bind(
    &connection_metadata::on_message,
    metadata_ptr,
    websocketpp::lib::placeholders::_1,
    websocketpp::lib::placeholders::_2
));
```

--------------------------------

### Finalize Target Properties (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/echo_server/CMakeLists.txt

This CMake snippet sets properties for the target, specifically placing it within a 'examples' folder in the build environment. The 'final_target()' function likely performs any remaining setup or cleanup for the target. The 'set_target_properties' command is a standard CMake function for configuring build targets.

```cmake
final_target ()

set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
```

--------------------------------

### Export and Install CMake Package Configuration

Source: https://github.com/zaphoyd/websocketpp/blob/master/CMakeLists.txt

This snippet generates and installs the project's CMake configuration files. It uses CMakePackageConfigHelpers to ensure the package can be easily consumed by other projects.

```cmake
include(CMakePackageConfigHelpers)
configure_package_config_file(websocketpp-config.cmake.in
  "${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-config.cmake"
  PATH_VARS INSTALL_INCLUDE_DIR
  INSTALL_DESTINATION "${INSTALL_CMAKE_DIR}"
  NO_CHECK_REQUIRED_COMPONENTS_MACRO
)
write_basic_package_version_file("${PROJECT_BINARY_DIR}${CMAKE_FILES_DIRECTORY}/websocketpp-configVersion.cmake"
  VERSION ${WEBSOCKETPP_VERSION}
  COMPATIBILITY ExactVersion)
```

--------------------------------

### GET /stress_stats

Source: https://github.com/zaphoyd/websocketpp/wiki/wsperf:-stress_test

Retrieves real-time statistics for the ongoing stress test.

```APIDOC
## GET /stress_stats

### Description
Retrieves current statistics for the active stress test. This includes data on connections, messages, and performance metrics.

### Method
GET

### Endpoint
/stress_stats

### Parameters
None

### Response
#### Success Response (200)
- **connection_stats** (array) - Statistics for each connection.
  - **connectionid** (string) - Unique ID for the connection.
  - **start_connect_timestamp** (integer) - Timestamp when the connection attempt started.
  - **end_tcp_start_ws_handshake_timestamp** (integer) - Timestamp when TCP connection ended and WebSocket handshake began.
  - **on_open_timestamp** (integer) - Timestamp when the connection was successfully opened.
  - **on_fail_timestamp** (integer) - Timestamp when the connection failed.
  - **on_close_timestamp** (integer) - Timestamp when the connection was closed.
  - **connection_close_sent_timestamp** (integer) - Timestamp when the connection close was sent.
- **message_stats** (array) - Statistics for each message.
  - **messageid** (string) - Unique ID for the message.
  - **send_connectionid** (string) - ID of the connection that sent the message.
  - **recv_connectionid** (string) - ID of the connection that received the message.
  - **send_timestamp** (integer) - Timestamp when the message was sent.
  - **recv_timestamp** (integer) - Timestamp when the message was received.
  - **opcode** (string) - WebSocket opcode of the message.
  - **payload_length** (integer) - Length of the message payload in bytes.

#### Response Example
```json
{
  "connection_stats": [
    {
      "connectionid": "conn_1",
      "start_connect_timestamp": 1678886400000,
      "end_tcp_start_ws_handshake_timestamp": 1678886400100,
      "on_open_timestamp": 1678886400200,
      "on_fail_timestamp": null,
      "on_close_timestamp": null,
      "connection_close_sent_timestamp": null
    }
  ],
  "message_stats": [
    {
      "messageid": "msg_101",
      "send_connectionid": "conn_1",
      "recv_connectionid": "server_conn_1",
      "send_timestamp": 1678886405000,
      "recv_timestamp": 1678886405150,
      "opcode": "TEXT",
      "payload_length": 1024
    }
  ]
}
```
```

--------------------------------

### Disable All Access Channels

Source: https://github.com/zaphoyd/websocketpp/blob/master/docs/logging.dox

This example demonstrates how to disable all access logging channels using the `clear_access_channels` method. This is useful for turning off all routine event logging.

```cpp
clear_access_channels(log::alevel::all)
```

--------------------------------

### Complete Utility Server Implementation

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_server/utility_server.md

A full C++ implementation of a WebSocket++ server class. It includes logging configuration, Asio initialization, and the run loop.

```cpp
#define ASIO_STANDALONE

#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
#include <functional>

typedef websocketpp::server<websocketpp::config::asio> server;

class utility_server {
public:
    utility_server() {
        m_endpoint.set_error_channels(websocketpp::log::elevel::all);
        m_endpoint.set_access_channels(websocketpp::log::alevel::all ^ websocketpp::log::alevel::frame_payload);
        m_endpoint.init_asio();
    }

    void run() {
        m_endpoint.listen(9002);
        m_endpoint.start_accept();
        m_endpoint.run();
    }
private:
    server m_endpoint;
};

int main() {
    utility_server s;
    s.run();
    return 0;
}
```

--------------------------------

### Build WebSocket++ with Asio

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_server/utility_server.md

Commands to compile the WebSocket++ server using either standalone Asio or Boost Asio. Requires C++11 support and appropriate include paths.

```bash
c++ -std=c++11 step1.cpp
c++ -std=c++11 step1.cpp -lboost_system
```

--------------------------------

### Create TLS/Secure WebSocket Server with OpenSSL

Source: https://context7.com/zaphoyd/websocketpp/llms.txt

Demonstrates how to initialize a secure WebSocket server using the asio_tls configuration. It includes a TLS initialization handler to load certificates, private keys, and Diffie-Hellman parameters.

```cpp
#include <websocketpp/config/asio.hpp>
#include <websocketpp/server.hpp>
#include <iostream>

typedef websocketpp::server<websocketpp::config::asio_tls> server;
typedef websocketpp::lib::shared_ptr<websocketpp::lib::asio::ssl::context> context_ptr;

std::string get_password() {
    return "test";
}

context_ptr on_tls_init(websocketpp::connection_hdl hdl) {
    namespace asio = websocketpp::lib::asio;

    context_ptr ctx = websocketpp::lib::make_shared<asio::ssl::context>(
        asio::ssl::context::sslv23
    );

    try {
        ctx->set_options(
            asio::ssl::context::default_workarounds |
            asio::ssl::context::no_sslv2 |
            asio::ssl::context::no_sslv3 |
            asio::ssl::context::single_dh_use
        );
        ctx->set_password_callback(websocketpp::lib::bind(&get_password));
        ctx->use_certificate_chain_file("server.pem");
        ctx->use_private_key_file("server.pem", asio::ssl::context::pem);
        ctx->use_tmp_dh_file("dh.pem");
    } catch (std::exception& e) {
        std::cout << "TLS init error: " << e.what() << std::endl;
    }
    return ctx;
}

void on_message(server* s, websocketpp::connection_hdl hdl, server::message_ptr msg) {
    s->send(hdl, msg->get_payload(), msg->get_opcode());
}

int main() {
    server tls_server;

    tls_server.init_asio();
    tls_server.set_message_handler(
        websocketpp::lib::bind(&on_message, &tls_server,
            websocketpp::lib::placeholders::_1,
            websocketpp::lib::placeholders::_2)
    );
    tls_server.set_tls_init_handler(websocketpp::lib::bind(&on_tls_init,
        websocketpp::lib::placeholders::_1));

    tls_server.listen(9002);
    tls_server.start_accept();
    tls_server.run();
}
```

--------------------------------

### Implement WebSocket++ Close Handler

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

A callback function that executes when a connection is closed. It retrieves the remote close code and reason from the connection object and updates the local metadata status.

```cpp
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();
}
```

--------------------------------

### Initialize Asio Transport

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_server/utility_server.md

Initializes the underlying Asio transport system for the endpoint. This method is specific to Asio-based configurations and prepares the internal io_service.

```cpp
m_endpoint.init_asio();
```

--------------------------------

### Send Text and Binary Messages with WebSocket++

Source: https://context7.com/zaphoyd/websocketpp/llms.txt

Demonstrates sending text and binary messages to a connected client. It includes setting up a basic WebSocket server, handling new connections to send initial messages, and processing incoming messages to echo them back. Dependencies include the WebSocket++ library and ASIO.

```cpp
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>

typedef websocketpp::server<websocketpp::config::asio> server;

class message_server {
public:
    message_server() {
        m_server.init_asio();
        m_server.set_message_handler(
            websocketpp::lib::bind(&message_server::on_message, this,
                websocketpp::lib::placeholders::_1,
                websocketpp::lib::placeholders::_2)
        );
        m_server.set_open_handler(
            websocketpp::lib::bind(&message_server::on_open, this,
                websocketpp::lib::placeholders::_1)
        );
    }

    void on_open(websocketpp::connection_hdl hdl) {
        // Send text message
        websocketpp::lib::error_code ec;
        m_server.send(hdl, "Welcome!", websocketpp::frame::opcode::text, ec);
        if (ec) {
            std::cout << "Send error: " << ec.message() << std::endl;
        }

        // Send binary message
        std::vector<uint8_t> binary_data = {0x01, 0x02, 0x03, 0x04};
        m_server.send(hdl, binary_data.data(), binary_data.size(),
            websocketpp::frame::opcode::binary, ec);
    }

    void on_message(websocketpp::connection_hdl hdl, server::message_ptr msg) {
        // Check message type
        if (msg->get_opcode() == websocketpp::frame::opcode::text) {
            std::cout << "Text message: " << msg->get_payload() << std::endl;
        } else if (msg->get_opcode() == websocketpp::frame::opcode::binary) {
            std::cout << "Binary message: "
                      << websocketpp::utility::to_hex(msg->get_payload())
                      << std::endl;
        }

        // Echo back
        m_server.send(hdl, msg->get_payload(), msg->get_opcode());
    }

    void run(uint16_t port) {
        m_server.listen(port);
        m_server.start_accept();
        m_server.run();
    }

private:
    server m_server;
};

int main() {
    message_server s;
    s.run(9002);
}

```

--------------------------------

### Implement WebSocket Client with Asio Transport

Source: https://context7.com/zaphoyd/websocketpp/llms.txt

This snippet shows how to create a WebSocket client that connects to a remote server. It includes logic for connection initialization, message handling, and running the client event loop.

```cpp
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>
#include <iostream>

typedef websocketpp::client<websocketpp::config::asio_client> client;
typedef websocketpp::config::asio_client::message_type::ptr message_ptr;

void on_message(client* c, websocketpp::connection_hdl hdl, message_ptr msg) {
    std::cout << "Received: " << msg->get_payload() << std::endl;

    websocketpp::lib::error_code ec;
    c->send(hdl, msg->get_payload(), msg->get_opcode(), ec);
    if (ec) {
        std::cout << "Send failed: " << ec.message() << std::endl;
    }
}

int main(int argc, char* argv[]) {
    client c;
    std::string uri = "ws://localhost:9002";

    try {
        // Configure logging
        c.set_access_channels(websocketpp::log::alevel::all);
        c.clear_access_channels(websocketpp::log::alevel::frame_payload);

        // Initialize ASIO
        c.init_asio();

        // Register message handler
        c.set_message_handler(
            websocketpp::lib::bind(&on_message, &c,
                websocketpp::lib::placeholders::_1,
                websocketpp::lib::placeholders::_2)
        );

        // Create connection
        websocketpp::lib::error_code ec;
        client::connection_ptr con = c.get_connection(uri, ec);
        if (ec) {
            std::cout << "Connection error: " << ec.message() << std::endl;
            return 1;
        }

        // Connect and run
        c.connect(con);
        c.run();
    } catch (websocketpp::exception const & e) {
        std::cout << e.what() << std::endl;
    }
}
```

--------------------------------

### Initializing and Building Executable Target (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/broadcast_server/CMakeLists.txt

This CMake code initializes a target named 'broadcast_server' and then builds it as an executable using the previously globbed source and header files. The build_executable command is a custom macro that likely encapsulates standard CMake commands for creating an executable. The final_target command suggests a concluding step in the build process for this target.

```cmake
init_target (broadcast_server)

build_executable (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})

final_target ()
```

--------------------------------

### Finalize Target and Set Properties (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/examples/iostream_server/CMakeLists.txt

These CMake commands finalize the target definition and set its properties, such as placing it in a specific folder within the build environment. The `final_target()` command is likely a custom macro, while `set_target_properties` is a standard CMake function. This helps organize build outputs.

```cmake
final_target ()
set_target_properties(${TARGET_NAME} PROPERTIES FOLDER "examples")
```

--------------------------------

### Implement websocket_endpoint destructor for connection cleanup

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

The destructor stops perpetual mode to allow the network thread to exit and iterates through active connections to initiate a clean close. It ensures all resources are properly released by joining the network thread after closing connections.

```cpp
~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") {
            // Only close open connections
            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();
}
```

--------------------------------

### Implement HTTP Handlers in WebSocket++

Source: https://context7.com/zaphoyd/websocketpp/llms.txt

Shows how to configure a WebSocket++ server to respond to standard HTTP requests. This is useful for serving static files or providing RESTful API endpoints alongside WebSocket services.

```cpp
#include <websocketpp/config/asio_no_tls.hpp>
#include <websocketpp/server.hpp>
#include <fstream>

typedef websocketpp::server<websocketpp::config::asio> server;

class http_server {
public:
    http_server() {
        m_server.init_asio();
        m_server.set_http_handler(
            websocketpp::lib::bind(&http_server::on_http, this,
                websocketpp::lib::placeholders::_1));
        m_server.set_message_handler(
            websocketpp::lib::bind(&http_server::on_message, this,
                websocketpp::lib::placeholders::_1,
                websocketpp::lib::placeholders::_2));
    }

    void on_http(websocketpp::connection_hdl hdl) {
        server::connection_ptr con = m_server.get_con_from_hdl(hdl);

        std::string resource = con->get_resource();
        std::cout << "HTTP request for: " << resource << std::endl;

        if (resource == "/") {
            con->set_body("<!DOCTYPE html><html><body>"
                          "<h1>WebSocket++ HTTP Server</h1>"
                          "<p>Connect via WebSocket at ws://localhost:9002</p>"
                          "</body></html>");
            con->set_status(websocketpp::http::status_code::ok);
        } else if (resource == "/api/status") {
            con->set_body("{\"status\": \"running\", \"connections\": 0}");
            con->append_header("Content-Type", "application/json");
            con->set_status(websocketpp::http::status_code::ok);
        } else {
            con->set_body("<!DOCTYPE html><html><body>"
                          "<h1>404 Not Found</h1>"
                          "</body></html>");
            con->set_status(websocketpp::http::status_code::not_found);
        }
    }

    void on_message(websocketpp::connection_hdl hdl, server::message_ptr msg) {
        m_server.send(hdl, msg->get_payload(), msg->get_opcode());
    }

    void run(uint16_t port) {
        m_server.listen(port);
        m_server.start_accept();
        m_server.run();
    }

private:
    server m_server;
};

int main() {
    http_server s;
    s.run(9002);
}
```

--------------------------------

### Configure Server Logging

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_server/utility_server.md

Sets the error and access logging channels for the endpoint. It enables all error logs and all access logs except for frame payloads to reduce noise.

```cpp
m_endpoint.set_error_channels(websocketpp::log::elevel::all);
m_endpoint.set_access_channels(websocketpp::log::alevel::all ^ websocketpp::log::alevel::frame_payload);
```

--------------------------------

### Implement Perpetual Mode Client with WebSocket++

Source: https://context7.com/zaphoyd/websocketpp/llms.txt

This snippet demonstrates a C++ class that encapsulates a WebSocket++ client, utilizing start_perpetual() to keep the ASIO event loop active. It provides methods for connecting, sending messages, and closing connections while managing thread lifecycle and connection handles.

```cpp
#include <websocketpp/config/asio_no_tls_client.hpp>
#include <websocketpp/client.hpp>
#include <websocketpp/common/thread.hpp>
#include <map>

typedef websocketpp::client<websocketpp::config::asio_client> client;

class websocket_endpoint {
public:
    websocket_endpoint() : m_next_id(0) {
        m_endpoint.clear_access_channels(websocketpp::log::alevel::all);
        m_endpoint.clear_error_channels(websocketpp::log::elevel::all);

        m_endpoint.init_asio();
        m_endpoint.start_perpetual();

        m_thread = websocketpp::lib::make_shared<websocketpp::lib::thread>(
            &client::run, &m_endpoint);
    }

    ~websocket_endpoint() {
        m_endpoint.stop_perpetual();

        for (auto& pair : m_connections) {
            websocketpp::lib::error_code ec;
            m_endpoint.close(pair.second, websocketpp::close::status::going_away, "", ec);
        }

        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 << "Connect error: " << ec.message() << std::endl;
            return -1;
        }

        int new_id = m_next_id++;
        m_connections[new_id] = con->get_handle();
        m_endpoint.connect(con);

        return new_id;
    }

    void send(int id, std::string message) {
        websocketpp::lib::error_code ec;
        auto it = m_connections.find(id);
        if (it == m_connections.end()) {
            std::cout << "Connection not found" << std::endl;
            return;
        }

        m_endpoint.send(it->second, message,
            websocketpp::frame::opcode::text, ec);
        if (ec) {
            std::cout << "Send error: " << ec.message() << std::endl;
        }
    }

    void close(int id, websocketpp::close::status::value code, std::string reason) {
        websocketpp::lib::error_code ec;
        auto it = m_connections.find(id);
        if (it == m_connections.end()) {
            return;
        }

        m_endpoint.close(it->second, code, reason, ec);
    }

private:
    client m_endpoint;
    websocketpp::lib::shared_ptr<websocketpp::lib::thread> m_thread;
    std::map<int, websocketpp::connection_hdl> m_connections;
    int m_next_id;
};

int main() {
    websocket_endpoint endpoint;

    int id = endpoint.connect("ws://localhost:9002");
    if (id >= 0) {
        endpoint.send(id, "Hello, WebSocket!");
        endpoint.close(id, websocketpp::close::status::normal, "Done");
    }
}
```

--------------------------------

### C++ WebSocket++ Message Handler Implementation

Source: https://github.com/zaphoyd/websocketpp/blob/master/tutorials/utility_client/utility_client.md

Implements a message handler for WebSocket++ that processes incoming messages. It distinguishes between text and binary messages, storing text payloads directly and converting binary payloads to hexadecimal format before storing. This handler is designed to be registered with a connection to process received data.

```cpp
void on_message(websocketpp::connection_hdl hdl, client::message_ptr msg) {
    if (msg->get_opcode() == websocketpp::frame::opcode::text) {
        m_messages.push_back(msg->get_payload());
    } else {
        m_messages.push_back(websocketpp::utility::to_hex(msg->get_payload()));
    }
}
```

--------------------------------

### Initialize and Build Test Target (CMake)

Source: https://github.com/zaphoyd/websocketpp/blob/master/test/endpoint/CMakeLists.txt

Initializes a target named 'test_endpoint' and then builds it using the discovered source and header files. This is a standard CMake procedure for creating executable targets.

```cmake
init_target (test_endpoint)
build_test (${TARGET_NAME} ${SOURCE_FILES} ${HEADER_FILES})
```
Tokens:
Raw