Merge pull request #269 from c410-f3r/misc

Allow the building for ESP32 targets

README.md

@@ -20,6 +20,8 @@ A collection of different transport implementations and related tools focused pr
 10. [WebSocket Client/Server](https://c410-f3r.github.io/wtx/web-socket/index.html)
 11. [WebSocket over HTTP/2](https://c410-f3r.github.io/wtx/web-socket-over-http2/index.html)
 
+Every feature is optional and must be set at compile time. Please see the intended documentation for further information.
+
 Embedded devices with a working heap allocator can use this `no_std` crate.
 
 ## Performance

SECURITY.md

@@ -0,0 +1,3 @@
+# Security policy
+
+You can report security vulnerabilities with as much information as possible through our [security page](https://github.com/c410-f3r/wtx/security). Security advisories will be available at <https://github.com/c410-f3r/wtx/security/advisories>.

clippy.toml

@@ -1,7 +1,10 @@
 disallowed-methods = [
     "<[u8]>::rsplit",
     "<[u8]>::split",
+    "alloc::sync::Arc",
     "core::str::from_utf8",
+    "core::sync::atomic::AtomicU64",
+    "core::sync::atomic::AtomicUsize",
     "str::rsplit",
 ]
 disallowed-types = [

wtx-docs/src/grpc/README.md

@@ -7,6 +7,8 @@ Basic implementation that currently only supports unary calls. gRPC is an high-p
 
 Due to the lack of an official parser, the definitions of a `Service` must be manually typed.
 
+Independent benchmarks are available <https://github.com/LesnyRumcajs/grpc_bench>.
+
 To use this functionality, it is necessary to activate the `grpc` feature.
 
 ## Client Example

wtx-docs/src/web-socket-over-http2/README.md

@@ -7,7 +7,7 @@ While HTTP/2 inherently supports full-duplex communication, web browsers typical
 1. Servers can efficiently handle multiple concurrent streams within a single TCP connection
 2. Client applications can continue using existing WebSocket APIs without modification
 
-For this particular scenario, the `no-masking` parameter defined in <https://datatracker.ietf.org/doc/html/draft-damjanovic-websockets-nomasking-02> is also supported.
+For this particular scenario the `no-masking` parameter defined in <https://datatracker.ietf.org/doc/html/draft-damjanovic-websockets-nomasking-02> is also supported.
 
 To use this functionality, it is necessary to activate the `http2` and `web-socket` features.
 

wtx-instances/generic-examples/grpc-server.rs

@@ -25,11 +25,12 @@ async fn main() -> wtx::Result<()> {
   )?;
   ServerFrameworkBuilder::new(router)
     .with_req_aux(|| QuickProtobuf::default())
-    .listen_tokio_rustls(
+    .tokio_rustls(
       (wtx_instances::CERT, wtx_instances::KEY),
       &wtx_instances::host_from_args(),
       Xorshift64::from(simple_seed()),
       |error| eprintln!("{error}"),
+      |_| Ok(()),
     )
     .await
 }

wtx-instances/http-server-framework-examples/http-server-framework-cors.rs

@@ -10,9 +10,12 @@ async fn main() -> wtx::Result<()> {
   let router = Router::new(wtx::paths!(("/hello", get(hello))), CorsMiddleware::permissive())?;
   ServerFrameworkBuilder::new(router)
     .without_aux()
-    .listen_tokio("0.0.0.0:9000", Xorshift64::from(simple_seed()), |error: wtx::Error| {
-      eprintln!("{error:?}")
-    })
+    .tokio(
+      "0.0.0.0:9000",
+      Xorshift64::from(simple_seed()),
+      |error: wtx::Error| eprintln!("{error:?}"),
+      |_| Ok(()),
+    )
     .await?;
   Ok(())
 }

wtx-instances/http-server-framework-examples/http-server-framework-redirect.rs

@@ -14,9 +14,12 @@ async fn main() -> wtx::Result<()> {
     Router::paths(wtx::paths!(("/permanent", get(permanent)), ("/temporary", get(temporary))))?;
   ServerFrameworkBuilder::new(router)
     .without_aux()
-    .listen_tokio(&wtx_instances::host_from_args(), Xorshift64::from(simple_seed()), |error| {
-      eprintln!("{error}")
-    })
+    .tokio(
+      &wtx_instances::host_from_args(),
+      Xorshift64::from(simple_seed()),
+      |error| eprintln!("{error}"),
+      |_| Ok(()),
+    )
     .await
 }
 

wtx-instances/http-server-framework-examples/http-server-framework-session.rs

@@ -54,7 +54,7 @@ async fn main() -> wtx::Result<()> {
   let rng_clone = rng.clone();
   ServerFrameworkBuilder::new(router)
     .with_conn_aux(move || (session.clone(), rng_clone.clone()))
-    .listen_tokio("0.0.0.0:9000", rng, |err| eprintln!("{err:?}"))
+    .tokio("0.0.0.0:9000", rng, |err| eprintln!("{err:?}"), |_| Ok(()))
     .await?;
   Ok(())
 }

wtx-instances/http-server-framework-examples/http-server-framework.rs

@@ -1,5 +1,5 @@
-//! An HTTP server framework showcasing nested routes, request middlewares, response
-//! middlewares, dynamic routes, PostgreSQL connections and JSON deserialization/serialization.
+//! An HTTP server framework showcasing nested routes, middlewares, manual streams, dynamic routes,
+//! PostgreSQL connections and JSON deserialization/serialization.
 //!
 //! Currently, only HTTP/2 is supported.
 //!
@@ -11,15 +11,16 @@ extern crate wtx;
 extern crate wtx_instances;
 
 use core::{fmt::Write, ops::ControlFlow};
-use tokio::net::TcpStream;
+use tokio::net::{tcp::OwnedWriteHalf, TcpStream};
 use wtx::{
   database::{Executor, Record},
   http::{
     server_framework::{
       get, post, Middleware, PathOwned, Router, SerdeJson, ServerFrameworkBuilder, StateClean,
     },
-    ReqResBuffer, Request, Response, StatusCode,
+    ManualStream, ReqResBuffer, Request, Response, StatusCode,
   },
+  http2::{Http2Buffer, Http2DataTokio, Http2ErrorCode, ServerStream},
   misc::{simple_seed, Xorshift64},
   pool::{PostgresRM, SimplePoolTokio},
 };
@@ -35,14 +36,18 @@ async fn main() -> wtx::Result<()> {
       "/say",
       Router::new(wtx::paths!(("/hello", get(hello)), ("/world", get(world))), CustomMiddleware,)?,
     ),
+    ("/stream", get(stream)),
   ))?;
   let rm = PostgresRM::tokio("postgres://USER:PASSWORD@localhost/DB_NAME".into());
   let pool = Pool::new(4, rm);
   ServerFrameworkBuilder::new(router)
     .with_req_aux(move || pool.clone())
-    .listen_tokio(&wtx_instances::host_from_args(), Xorshift64::from(simple_seed()), |error| {
-      eprintln!("{error:?}")
-    })
+    .tokio(
+      &wtx_instances::host_from_args(),
+      Xorshift64::from(simple_seed()),
+      |error| eprintln!("{error:?}"),
+      |_| Ok(()),
+    )
     .await
 }
 
@@ -76,6 +81,17 @@ async fn json(_: SerdeJson<DeserializeExample>) -> wtx::Result<SerdeJson<Seriali
   Ok(SerdeJson(SerializeExample { _baz: [1, 2, 3, 4] }))
 }
 
+async fn stream(
+  mut manual_stream: ManualStream<
+    (),
+    ServerStream<Http2DataTokio<Http2Buffer, OwnedWriteHalf, false>>,
+    Pool,
+  >,
+) -> wtx::Result<()> {
+  manual_stream.stream.common().send_go_away(Http2ErrorCode::NoError).await;
+  Ok(())
+}
+
 async fn world() -> &'static str {
   "world"
 }

wtx-instances/http2-examples/http2-server.rs

@@ -9,10 +9,10 @@ use tokio::{io::WriteHalf, net::TcpStream};
 use tokio_rustls::server::TlsStream;
 use wtx::{
   http::{
-    AutoStream, ManualServerStreamTokio, OptionedServer, ReqResBuffer, Response, StatusCode,
-    StreamMode,
+    is_web_socket_handshake, AutoStream, ManualServerStreamTokio, OperationMode, OptionedServer,
+    ReqResBuffer, Response, StatusCode,
   },
-  http2::{is_web_socket_handshake, Http2Buffer, Http2Params, WebSocketOverStream},
+  http2::{Http2Buffer, Http2Params, WebSocketOverStream},
   misc::{simple_seed, TokioRustlsAcceptor, Vector, Xorshift64},
   web_socket::{Frame, OpCode},
 };
@@ -33,14 +33,17 @@ async fn main() -> wtx::Result<()> {
     },
     |error| eprintln!("{error}"),
     manual,
-    || Ok((Vector::new(), ReqResBuffer::empty())),
-    |headers, method, protocol| {
-      Ok(if is_web_socket_handshake(headers, method, protocol) {
-        StreamMode::Manual(())
-      } else {
-        StreamMode::Auto
-      })
+    |_, protocol, req, _| {
+      Ok((
+        (),
+        if is_web_socket_handshake(&mut req.rrd.headers, req.method, protocol) {
+          OperationMode::Manual
+        } else {
+          OperationMode::Auto
+        },
+      ))
     },
+    || Ok((Vector::new(), ReqResBuffer::empty())),
     (
       || {
         TokioRustlsAcceptor::without_client_auth()
@@ -54,17 +57,21 @@ async fn main() -> wtx::Result<()> {
   .await
 }
 
-async fn auto(mut ha: AutoStream<(), Vector<u8>>) -> Result<Response<ReqResBuffer>, wtx::Error> {
+async fn auto(
+  _: (),
+  mut ha: AutoStream<(), Vector<u8>>,
+) -> Result<Response<ReqResBuffer>, wtx::Error> {
   ha.req.rrd.clear();
   Ok(ha.req.into_response(StatusCode::Ok))
 }
 
 async fn manual(
-  mut hm: ManualServerStreamTokio<(), Http2Buffer, Vector<u8>, (), WriteHalf<TlsStream<TcpStream>>>,
+  _: (),
+  mut hm: ManualServerStreamTokio<(), Http2Buffer, Vector<u8>, WriteHalf<TlsStream<TcpStream>>>,
 ) -> Result<(), wtx::Error> {
   let rng = Xorshift64::from(simple_seed());
-  hm.headers.clear();
-  let mut wos = WebSocketOverStream::new(&hm.headers, false, rng, hm.stream).await?;
+  hm.req.rrd.headers.clear();
+  let mut wos = WebSocketOverStream::new(&hm.req.rrd.headers, false, rng, hm.stream).await?;
   loop {
     let mut frame = wos.read_frame(&mut hm.stream_aux).await?;
     match (frame.op_code(), frame.text_payload()) {

wtx-instances/http2-examples/http2-web-socket.rs

@@ -10,8 +10,8 @@ extern crate wtx_instances;
 use core::mem;
 use tokio::net::TcpListener;
 use wtx::{
-  http::{Headers, ReqResBuffer},
-  http2::{is_web_socket_handshake, Http2Buffer, Http2Params, Http2Tokio, WebSocketOverStream},
+  http::{is_web_socket_handshake, Headers, ReqResBuffer},
+  http2::{Http2Buffer, Http2Params, Http2Tokio, WebSocketOverStream},
   misc::{simple_seed, Either, TokioRustlsAcceptor, Vector, Xorshift64},
   web_socket::{Frame, OpCode},
 };
@@ -34,8 +34,9 @@ async fn main() -> wtx::Result<()> {
   .await?;
   tokio::spawn(frame_reader);
   let (mut stream, headers_opt) = match http2
-    .stream(ReqResBuffer::empty(), |headers, method, protocol| {
-      is_web_socket_handshake(headers, method, protocol).then(|| mem::take(headers))
+    .stream(ReqResBuffer::empty(), |req, protocol| {
+      let rslt = is_web_socket_handshake(&req.rrd.headers, req.method, protocol);
+      rslt.then(|| mem::take(&mut req.rrd.headers))
     })
     .await?
   {

wtx-instances/src/bin/h2load.rs

@@ -5,8 +5,8 @@
 use tokio::net::tcp::OwnedWriteHalf;
 use wtx::{
   http::{
-    AutoStream, ManualServerStreamTokio, OptionedServer, ReqResBuffer, Response, StatusCode,
-    StreamMode,
+    AutoStream, ManualServerStreamTokio, OperationMode, OptionedServer, ReqResBuffer, Response,
+    StatusCode,
   },
   http2::{Http2Buffer, Http2Params},
   misc::{simple_seed, Xorshift64},
@@ -28,19 +28,20 @@ async fn main() -> wtx::Result<()> {
     },
     |error| eprintln!("{error}"),
     manual,
+    |_, _, _, _| Ok(((), OperationMode::Auto)),
     || Ok(((), ReqResBuffer::empty())),
-    |_, _, _| Ok(StreamMode::Auto),
     (|| Ok(()), |_| {}, |_, stream| async move { Ok(stream.into_split()) }),
   )
   .await
 }
-async fn auto(mut ha: AutoStream<(), ()>) -> Result<Response<ReqResBuffer>, wtx::Error> {
+async fn auto(_: (), mut ha: AutoStream<(), ()>) -> Result<Response<ReqResBuffer>, wtx::Error> {
   ha.req.rrd.clear();
   Ok(ha.req.into_response(StatusCode::Ok))
 }
 
 async fn manual(
-  _: ManualServerStreamTokio<(), Http2Buffer, (), (), OwnedWriteHalf>,
+  _: (),
+  _: ManualServerStreamTokio<(), Http2Buffer, (), OwnedWriteHalf>,
 ) -> Result<(), wtx::Error> {
   Ok(())
 }

wtx-instances/src/bin/h2spec-high-server.rs

@@ -5,8 +5,8 @@
 use tokio::net::tcp::OwnedWriteHalf;
 use wtx::{
   http::{
-    AutoStream, ManualServerStreamTokio, OptionedServer, ReqResBuffer, Response, StatusCode,
-    StreamMode,
+    AutoStream, ManualServerStreamTokio, OperationMode, OptionedServer, ReqResBuffer, Response,
+    StatusCode,
   },
   http2::{Http2Buffer, Http2Params},
   misc::{simple_seed, Xorshift64},
@@ -20,21 +20,22 @@ async fn main() -> wtx::Result<()> {
     || Ok(((), Http2Buffer::new(Xorshift64::from(simple_seed())), Http2Params::default())),
     |error| eprintln!("{error}"),
     manual,
+    |_, _, _, _| Ok(((), OperationMode::Auto)),
     || Ok(((), ReqResBuffer::empty())),
-    |_, _, _| Ok(StreamMode::Auto),
     (|| Ok(()), |_| {}, |_, stream| async move { Ok(stream.into_split()) }),
   )
   .await
 }
 
-async fn auto(mut ha: AutoStream<(), ()>) -> Result<Response<ReqResBuffer>, wtx::Error> {
+async fn auto(_: (), mut ha: AutoStream<(), ()>) -> Result<Response<ReqResBuffer>, wtx::Error> {
   ha.req.rrd.clear();
   ha.req.rrd.body.extend_from_copyable_slice(b"Hello")?;
   Ok(ha.req.into_response(StatusCode::Ok))
 }
 
 async fn manual(
-  _: ManualServerStreamTokio<(), Http2Buffer, (), (), OwnedWriteHalf>,
+  _: (),
+  _: ManualServerStreamTokio<(), Http2Buffer, (), OwnedWriteHalf>,
 ) -> Result<(), wtx::Error> {
   Ok(())
 }

wtx-instances/src/bin/h2spec-low-server.rs

@@ -24,7 +24,7 @@ async fn main() -> wtx::Result<()> {
         let _jh = tokio::spawn(frame_reader);
         loop {
           let (mut http2_stream, headers) = match http2
-            .stream(ReqResBuffer::default(), |headers, _, _| mem::take(headers))
+            .stream(ReqResBuffer::default(), |req, _| mem::take(&mut req.rrd.headers))
             .await?
           {
             Either::Left(_) => return wtx::Result::Ok(()),