Add feature for early testing of feature(read_buf) (#248)

Also update to rustls 0.20.4.

Author: divergentdave

Cargo.toml

@@ -18,10 +18,11 @@ links = "rustls_ffi"
 # interfering with copies of the global logger brought in by other Rust
 # libraries.
 no_log_capture = []
+read_buf = ["rustls/read_buf"]
 
 [dependencies]
 # Keep in sync with RUSTLS_CRATE_VERSION in build.rs
-rustls = { version = "=0.20.2", features = [ "dangerous_configuration" ] }
+rustls = { version = "=0.20.4", features = [ "dangerous_configuration" ] }
 webpki = "0.22"
 libc = "0.2"
 sct = "0.7"

build.rs

@@ -3,7 +3,7 @@ use std::io::Write;
 use std::{env, fs, path::PathBuf};
 
 // Keep in sync with Cargo.toml.
-const RUSTLS_CRATE_VERSION: &str = "0.20.2";
+const RUSTLS_CRATE_VERSION: &str = "0.20.4";
 
 fn main() {
     let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());

cbindgen.toml

@@ -8,3 +8,6 @@ rename_variants = "ScreamingSnakeCase"
 
 [export]
 include = ["rustls_tls_version"]
+
+[defines]
+"feature = read_buf" = "DEFINE_READ_BUF"

src/connection.rs

@@ -471,6 +471,45 @@ impl rustls_connection {
         }
     }
 
+    /// Read up to `count` plaintext bytes from the `rustls_connection` into `buf`.
+    /// On success, store the number of bytes read in *out_n (this may be less
+    /// than `count`). A success with *out_n set to 0 means "all bytes currently
+    /// available have been read, but more bytes may become available after
+    /// subsequent calls to rustls_connection_read_tls and
+    /// rustls_connection_process_new_packets."
+    ///
+    /// This experimental API is only available when using a nightly Rust compiler
+    /// and enabling the `read_buf` Cargo feature. It will be deprecated and later
+    /// removed in future versions.
+    ///
+    /// Unlike with `rustls_connection_read`, this function may be called with `buf`
+    /// pointing to an uninitialized memory buffer.
+    #[cfg(feature = "read_buf")]
+    #[no_mangle]
+    pub extern "C" fn rustls_connection_read_2(
+        conn: *mut rustls_connection,
+        buf: *mut std::mem::MaybeUninit<u8>,
+        count: size_t,
+        out_n: *mut size_t,
+    ) -> rustls_result {
+        ffi_panic_boundary! {
+            let conn: &mut Connection = try_mut_from_ptr!(conn);
+            let read_buf: &mut [std::mem::MaybeUninit<u8>] = try_mut_slice!(buf, count);
+            let out_n: &mut size_t = try_mut_from_ptr!(out_n);
+
+            let mut read_buf = std::io::ReadBuf::uninit(read_buf);
+
+            let n_read: usize = match conn.reader().read_buf(&mut read_buf) {
+                Ok(()) => read_buf.filled_len(),
+                Err(e) if e.kind() == ErrorKind::UnexpectedEof => return rustls_result::UnexpectedEof,
+                Err(e) if e.kind() == ErrorKind::WouldBlock => return rustls_result::PlaintextEmpty,
+                Err(_) => return rustls_result::Io,
+            };
+            *out_n = n_read;
+            rustls_result::Ok
+        }
+    }
+
     /// Free a rustls_connection. Calling with NULL is fine.
     /// Must not be called twice with the same value.
     #[no_mangle]

src/lib.rs

@@ -1,6 +1,7 @@
 #![crate_type = "staticlib"]
 #![allow(non_camel_case_types)]
 #![allow(clippy::not_unsafe_ptr_arg_deref)]
+#![cfg_attr(feature = "read_buf", feature(read_buf))]
 
 //! This package contains bindings for using rustls via a C API. If
 //! you're looking at this on docs.rs, [you may want the rustls docs

src/rustls.h

@@ -1007,6 +1007,28 @@ rustls_result rustls_connection_read(struct rustls_connection *conn,
                                      size_t count,
                                      size_t *out_n);
 
+#if defined(DEFINE_READ_BUF)
+/**
+ * Read up to `count` plaintext bytes from the `rustls_connection` into `buf`.
+ * On success, store the number of bytes read in *out_n (this may be less
+ * than `count`). A success with *out_n set to 0 means "all bytes currently
+ * available have been read, but more bytes may become available after
+ * subsequent calls to rustls_connection_read_tls and
+ * rustls_connection_process_new_packets."
+ *
+ * This experimental API is only available when using a nightly Rust compiler
+ * and enabling the `read_buf` Cargo feature. It will be deprecated and later
+ * removed in future versions.
+ *
+ * Unlike with `rustls_connection_read`, this function may be called with `buf`
+ * pointing to an uninitialized memory buffer.
+ */
+rustls_result rustls_connection_read_2(struct rustls_connection *conn,
+                                       uint8_t *buf,
+                                       size_t count,
+                                       size_t *out_n);
+#endif
+
 /**
  * Free a rustls_connection. Calling with NULL is fine.
  * Must not be called twice with the same value.