zoukankan html css js c++ java

quic examples client server

https://reposhub.com/rust/network-programming/cloudflare-quiche.html

Building

# 準備
$ apt-get install cmake
$ curl https://sh.rustup.rs -sSf | sh # 適宜PATH通してcargo使えるように

$ git clone https://github.com/cloudflare/quiche.git
$ cd ./quiche
quiche$ git submodule update --init
quiche$ cargo build --examples

quiche requires Rust 1.39 or later to build. The latest stable Rust release can be installed using rustup.

Once the Rust build environment is setup, the quiche source code can be fetched using git:

 $ git clone --recursive https://github.com/cloudflare/quiche

and then built using cargo:

 $ cargo build --examples

cargo can also be used to run the testsuite:

 $ cargo test

Note that BoringSSL, which is used to implement QUIC's cryptographic handshake based on TLS, needs to be built and linked to quiche. This is done automatically when building quiche using cargo, but requires the cmake, go and perl commands to be available during the build process. On Windows you also need NASM. The official BoringSSL documentation has more details.

In alternative you can use your own custom build of BoringSSL by configuring the BoringSSL directory with the QUICHE_BSSL_PATH environment variable:

 $ QUICHE_BSSL_PATH="/path/to/boringssl" cargo build --examples

root@ubuntu:~/quiche# cd examples/
root@ubuntu:~/quiche/examples# cd ..
root@ubuntu:~/quiche# cargo build --examples
   Compiling quiche v0.7.0 (/root/quiche)
    Finished dev [unoptimized + debuginfo] target(s) in 3.31s
root@ubuntu:~/quiche# find ./ -name http3-server 
./target/debug/examples/http3-server

server

quiche$ quiche$ mkdir ./examples/root
quiche$ echo 'It works!!' > ./examples/root/index.html

quiche$ target/debug/examples/http3-server

root@ubuntu:~/quiche/target/debug/examples# ./http3-server 
thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: TlsFail', examples/http3-server.rs:94:10
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
root@ubuntu:~/quiche/target/debug/examples#

90     let mut config = quiche::Config::new(quiche::PROTOCOL_VERSION).unwrap();
 91 
 92     config
 93         .load_cert_chain_from_pem_file("examples/cert.crt")
 94         .unwrap();
 95     config
 96         .load_priv_key_from_pem_file("examples/cert.key")
 97         .unwrap();

client.d                   http3-client.d                   http3-server.d                   qpack_decode-f30e13401191c909.d  qpack-encode.d                   server-310b42a31ecb34f8.d
root@ubuntu:~/quiche/target/debug/examples# cp http3-server ~/quiche
root@ubuntu:~/quiche/target/debug/examples#

client

quiche$ target/debug/examples/http3-client https://localhost:4433/index.html --no-verify
It works!!

root@ubuntu:~/quiche/target/debug/examples# ./http3-client https://localhost:4433/index.html
thread 'main' panicked at 'recv() failed: Os { code: 111, kind: ConnectionRefused, message: "Connection refused" }', examples/http3-client.rs:183:21
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
root@ubuntu:~/quiche/target/debug/examples#

-    quiche_config *config = quiche_config_new(0xbabababa);
+    quiche_config *config = quiche_config_new(QUICHE_PROTOCOL_VERSION);

HTTP/3

The quiche HTTP/3 module provides a high level API for sending and receiving HTTP requests and responses on top of the QUIC transport protocol.

Have a look at the examples/ directory for more complete examples on how to use the quiche API, including examples on how to use quiche in C/C++ applications (see below for more information).

Calling quiche from C/C++

quiche exposes a thin C API on top of the Rust API that can be used to more easily integrate quiche into C/C++ applications (as well as in other languages that allow calling C APIs via some form of FFI). The C API follows the same design of the Rust one, modulo the constraints imposed by the C language itself.

When running cargo build, a static library called libquiche.a will be built automatically alongside the Rust one. This is fully stand-alone and can be linked directly into C/C++ applications.