quic_client_example.cpp File Reference

#include <iostream>
#include <string>
#include <memory>
#include <thread>
#include <chrono>
#include <vector>
#include <atomic>
#include <condition_variable>
#include <mutex>
#include "internal/experimental/quic_client.h"

Include dependency graph for quic_client_example.cpp:

Go to the source code of this file.

Classes
class	QuicClientDemo
	Simple QUIC client demo. More...

Macros
#define	NETWORK_USE_EXPERIMENTAL

Functions
void	demo_with_config ()
	Example with custom configuration.
int	main (int argc, char *argv[])

Macro Definition Documentation

NETWORK_USE_EXPERIMENTAL

#define NETWORK_USE_EXPERIMENTAL

BSD 3-Clause License Copyright (c) 2024, Network System Project

QUIC Client Example

This example demonstrates how to use the QUIC client API to connect to a QUIC server and send/receive data.

Note: This sample uses messaging_quic_client directly instead of quic_facade because it needs QUIC-specific features like multi-stream support, 0-RTT, and connection statistics. The quic_facade returns i_protocol_client which provides a unified interface but doesn't expose QUIC-specific methods.

Key features demonstrated:

• Basic connection and disconnection
• Sending data on the default stream
• Creating and using multiple streams (QUIC-specific)
• Handling callbacks for various events
• Using configuration options

Definition at line 33 of file quic_client_example.cpp.

Function Documentation

demo_with_config()

void demo_with_config

(

)

Example with custom configuration.

Definition at line 253 of file quic_client_example.cpp.

{
    std::cout << "\n=== QUIC Client with Custom Config ===" << std::endl;
 
    // Create client directly for QUIC-specific features
    auto client = std::make_shared<core::messaging_quic_client>("config_demo_client");
 
    // Configure QUIC-specific options
    core::quic_client_config config;
    config.verify_server = false;  // For testing with self-signed certs
    config.alpn_protocols = {"h3"};
    config.max_idle_timeout_ms = 60000;  // 60 seconds
    config.enable_early_data = true;  // Enable 0-RTT
 
    // For mutual TLS, set optional fields:
    // config.ca_cert_file = "/path/to/ca.pem";
    // config.client_cert_file = "/path/to/client.pem";
    // config.client_key_file = "/path/to/client-key.pem";
 
    auto result = client->start_client("example.com", 443, config);
    if (result.is_err())
    {
        std::cout << "Expected failure (no server): " << result.error().message << std::endl;
    }
 
    (void)client->stop_client();
}

References config.

Referenced by main().

Here is the caller graph for this function:

main()

int main	(	int	argc,
		char *	argv[] )

Definition at line 281 of file quic_client_example.cpp.

{
    std::string host = "127.0.0.1";
    unsigned short port = 4433;
 
    if (argc >= 2)
    {
        host = argv[1];
    }
    if (argc >= 3)
    {
        port = static_cast<unsigned short>(std::stoi(argv[2]));
    }
 
    // Run the main demo
    QuicClientDemo demo(host, port);
 
    // Note: This will likely fail without a running QUIC server
    // The demo is primarily to show the API usage
    std::cout << "\nNote: This demo requires a running QUIC server." << std::endl;
    std::cout << "Without a server, connection will timeout." << std::endl;
    std::cout << std::endl;
 
    bool success = demo.run();
 
    // Also show configuration example
    demo_with_config();
 
    return success ? 0 : 1;
}

References demo_with_config(), and QuicClientDemo::run().

Here is the call graph for this function: