Bound reference lifetimes sourced from pointer parameters

librustls/src/acceptor.rs

@@ -367,7 +367,7 @@ impl rustls_accepted {
                 None => return Default::default(),
             };
             match alpn_iter.nth(i) {
-                Some(slice_bytes) => slice_bytes.into(),
+                Some(slice_bytes) => unsafe { rustls_slice_bytes::from(slice_bytes).into_static() },
                 None => rustls_slice_bytes::default(),
             }
         }
@@ -539,6 +539,7 @@ mod tests {
 
     use crate::certificate::rustls_certified_key;
     use crate::client::{rustls_client_config, rustls_client_config_builder};
+    use crate::ffi::try_slice;
     use crate::server::rustls_server_config_builder;
     use crate::verifier::rustls_server_cert_verifier;
 
@@ -574,7 +575,7 @@ mod tests {
         out_n: *mut size_t,
     ) -> rustls_io_result {
         let vecdeq: *mut VecDeque<u8> = userdata as *mut _;
-        let buf = slice::from_raw_parts(buf, n);
+        let buf = try_slice!(buf, n);
         (*vecdeq).extend(buf);
         *out_n = n;
         rustls_io_result(0)
@@ -765,7 +766,7 @@ mod tests {
         // Sort to ensure consistent comparison
         signature_schemes.sort();
 
-        #[cfg_attr(not(feature = "aws-lc-rs"), allow(unused_mut))]
+        #[cfg_attr(not(feature = "aws-lc-rs"), expect(unused_mut))]
         let mut expected_schemes = vec![
             SignatureScheme::RSA_PKCS1_SHA256,
             SignatureScheme::ECDSA_NISTP256_SHA256,

librustls/src/certificate.rs

@@ -1,7 +1,5 @@
-use std::ffi::CStr;
 use std::marker::PhantomData;
 use std::ptr::{NonNull, null};
-use std::slice;
 
 use libc::{c_char, size_t};
 use rustls::RootCertStore;
@@ -12,9 +10,9 @@ use rustls::sign::CertifiedKey;
 use crate::crypto_provider::{self, rustls_signing_key};
 use crate::error::{map_error, rustls_result};
 use crate::ffi::{
-    Castable, OwnershipArc, OwnershipBox, OwnershipRef, free_arc, free_box, set_arc_mut_ptr,
-    to_arc_const_ptr, to_boxed_mut_ptr, try_box_from_ptr, try_mut_from_ptr, try_ref_from_ptr,
-    try_ref_from_ptr_ptr, try_slice, try_take,
+    Castable, OwnershipArc, OwnershipBox, OwnershipRef, bound_ref, free_arc, free_box,
+    set_arc_mut_ptr, to_arc_const_ptr, to_boxed_mut_ptr, try_box_from_ptr, try_cstr,
+    try_mut_from_ptr, try_ref_from_ptr, try_ref_from_ptr_ptr, try_slice, try_take,
 };
 use crate::panic::ffi_panic_boundary;
 use crate::rslice::rustls_slice_bytes;
@@ -229,19 +227,11 @@ impl rustls_certified_key {
         cloned_key_out: *mut *const rustls_certified_key,
     ) -> rustls_result {
         ffi_panic_boundary! {
-            let cloned_key_out = unsafe {
-                match cloned_key_out.as_mut() {
-                    Some(c) => c,
-                    None => return rustls_result::NullParameter,
-                }
-            };
+            let cloned_key_out = try_ref_from_ptr_ptr!(cloned_key_out);
             let certified_key = try_ref_from_ptr!(certified_key);
             let mut new_key = certified_key.clone();
-            new_key.ocsp = match NonNull::new(ocsp_response.cast_mut()) {
-                Some(ocsp_response) => {
-                    let ocsp_slice = unsafe { ocsp_response.as_ref() };
-                    Some(Vec::from(try_slice!(ocsp_slice.data, ocsp_slice.len)))
-                }
+            new_key.ocsp = match unsafe { bound_ref(&ocsp_response) } {
+                Some(ocsp) => Some(Vec::from(try_slice!(ocsp.data, ocsp.len))),
                 None => None,
             };
             *cloned_key_out = to_arc_const_ptr(new_key);
@@ -386,11 +376,7 @@ impl rustls_root_cert_store_builder {
                 Some(b) => b,
             };
 
-            let Some(filename) = NonNull::new(filename.cast_mut()) else {
-                return rustls_result::NullParameter;
-            };
-            let filename = unsafe { CStr::from_ptr(filename.as_ptr()) };
-
+            let filename = try_cstr!(filename);
             let filename = filename.to_bytes();
             let filename = match std::str::from_utf8(filename) {
                 Ok(s) => s,

librustls/src/client.rs

@@ -1,7 +1,4 @@
-use std::ffi::CStr;
 use std::fmt::{Debug, Formatter};
-use std::ptr::NonNull;
-use std::slice;
 use std::sync::Arc;
 
 use libc::{c_char, size_t};
@@ -20,8 +17,8 @@ use crate::crypto_provider::{self, rustls_crypto_provider, rustls_hpke};
 use crate::error::{self, map_error, rustls_result};
 use crate::ffi::{
     Castable, OwnershipArc, OwnershipBox, free_arc, free_box, set_arc_mut_ptr, set_boxed_mut_ptr,
-    to_boxed_mut_ptr, try_box_from_ptr, try_clone_arc, try_mut_from_ptr, try_mut_from_ptr_ptr,
-    try_ref_from_ptr, try_ref_from_ptr_ptr, try_slice,
+    to_boxed_mut_ptr, try_box_from_ptr, try_clone_arc, try_cstr, try_mut_from_ptr,
+    try_mut_from_ptr_ptr, try_ref_from_ptr, try_ref_from_ptr_ptr, try_slice,
 };
 use crate::keylog::{CallbackKeyLog, rustls_keylog_log_callback, rustls_keylog_will_log_callback};
 use crate::panic::ffi_panic_boundary;
@@ -621,7 +618,6 @@ impl rustls_client_config_builder {
 ///
 /// server_name can contain a hostname, an IPv4 address in textual form, or an
 /// IPv6 address in textual form.
-#[allow(non_camel_case_types)]
 #[repr(C)]
 pub struct rustls_verify_server_cert_params<'a> {
     pub end_entity_cert_der: rustls_slice_bytes<'a>,
@@ -633,15 +629,15 @@ pub struct rustls_verify_server_cert_params<'a> {
 /// User-provided input to a custom certificate verifier callback.
 ///
 /// See `rustls_client_config_builder_dangerous_set_certificate_verifier()`.
-#[allow(non_camel_case_types)]
+#[expect(non_camel_case_types)]
 pub type rustls_verify_server_cert_user_data = *mut libc::c_void;
 
 /// A callback that is invoked to verify a server certificate.
 // According to the nomicon https://doc.rust-lang.org/nomicon/ffi.html#the-nullable-pointer-optimization):
 // > Option<extern "C" fn(c_int) -> c_int> is a correct way to represent a
 // > nullable function pointer using the C ABI (corresponding to the C type int (*)(int)).
 // So we use Option<...> here. This is the type that is passed from C code.
-#[allow(non_camel_case_types)]
+#[expect(non_camel_case_types)]
 pub type rustls_verify_server_cert_callback = Option<
     unsafe extern "C" fn(
         userdata: rustls_verify_server_cert_user_data,
@@ -810,6 +806,8 @@ impl rustls_client_config {
     /// point at a valid `rustls_connection`. The caller now owns the `rustls_connection`
     /// and must call `rustls_connection_free` when done with it.
     ///
+    /// This function copies the contents of `server_name`.
+    ///
     /// Uses the `rustls_client_config` to determine ALPN protocol support. Prefer
     /// `rustls_client_connection_new_alpn` to customize this per-connection.
     ///
@@ -845,6 +843,8 @@ impl rustls_client_config {
     /// point at a valid `rustls_connection`. The caller now owns the `rustls_connection`
     /// and must call `rustls_connection_free` when done with it.
     ///
+    /// This function copies the contents of `server_name`.
+    ///
     /// If this returns an error code, the memory pointed to by `conn_out` remains
     /// unchanged.
     ///
@@ -890,16 +890,14 @@ impl rustls_client_config {
         alpn_protocols: Vec<Vec<u8>>,
         conn_out: *mut *mut rustls_connection,
     ) -> rustls_result {
-        let Some(server_name) = NonNull::new(server_name.cast_mut()) else {
-            return rustls_result::NullParameter;
-        };
-        let server_name = unsafe { CStr::from_ptr(server_name.as_ptr()) };
+        let server_name = try_cstr!(server_name);
         let Ok(server_name) = server_name.to_str() else {
             return rustls_result::InvalidDnsNameError;
         };
-        let Ok(server_name) = server_name.try_into() else {
+        let Ok(server_name) = ServerName::try_from(server_name) else {
             return rustls_result::InvalidDnsNameError;
         };
+        let server_name = server_name.to_owned();
 
         set_boxed_mut_ptr(
             try_mut_from_ptr_ptr!(conn_out),

librustls/src/connection.rs

@@ -1,6 +1,6 @@
 use std::io::{ErrorKind, Read, Write};
-use std::{ffi::c_void, ptr::NonNull, ptr::null};
-use std::{ptr::null_mut, slice};
+use std::ptr::{NonNull, null_mut};
+use std::{ffi::c_void, ptr::null};
 
 use libc::{EINVAL, EIO, size_t};
 use rustls::CipherSuite::TLS_NULL_WITH_NULL_NULL;
@@ -46,7 +46,6 @@ impl Connection {
         }
     }
 
-    #[allow(dead_code)]
     pub(crate) fn as_client(&self) -> Option<&ClientConnection> {
         match &self.conn {
             rustls::Connection::Client(c) => Some(c),
@@ -61,15 +60,15 @@ impl Connection {
         }
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub(crate) fn as_client_mut(&mut self) -> Option<&mut ClientConnection> {
         match &mut self.conn {
             rustls::Connection::Client(c) => Some(c),
             _ => None,
         }
     }
 
-    #[allow(dead_code)]
+    #[expect(dead_code)]
     pub(crate) fn as_server_mut(&mut self) -> Option<&mut ServerConnection> {
         match &mut self.conn {
             rustls::Connection::Server(s) => Some(s),
@@ -564,16 +563,13 @@ impl rustls_connection {
     ) -> rustls_result {
         ffi_panic_boundary! {
             let conn = try_mut_from_ptr!(conn);
-            let Some(buf) = NonNull::new(buf) else {
-                return rustls_result::NullParameter;
-            };
             let Some(out_n) = NonNull::new(out_n) else {
                 return rustls_result::NullParameter;
             };
 
             // Safety: the memory pointed at by buf must be initialized
             // (required by documentation of this function).
-            let read_buf = try_slice_mut!(buf.as_ptr(), count);
+            let read_buf = try_slice_mut!(buf, count);
 
             let n_read = match conn.reader().read(read_buf) {
                 Ok(n) => n,
@@ -615,11 +611,10 @@ impl rustls_connection {
     ) -> rustls_result {
         ffi_panic_boundary! {
             let conn = try_mut_from_ptr!(conn);
-            let (Some(buf), Some(out_n)) = (NonNull::new(buf), NonNull::new(out_n)) else {
+            let Some(out_n) = NonNull::new(out_n) else {
                 return rustls_result::NullParameter;
             };
-            let mut read_buf: std::io::BorrowedBuf<'_, u8> =
-                try_slice_mut!(buf.as_ptr(), count).into();
+            let mut read_buf: std::io::BorrowedBuf<'_, u8> = try_slice_mut!(buf, count).into();
 
             let n_read = match conn.reader().read_buf(read_buf.unfilled()) {
                 Ok(()) => read_buf.filled().len(),

librustls/src/crypto_provider.rs

@@ -1,4 +1,3 @@
-use std::slice;
 use std::sync::Arc;
 
 use libc::size_t;
@@ -531,7 +530,7 @@ impl Hpke {
     pub(crate) fn grease_public_key(
         &self,
         provider: &CryptoProvider,
-    ) -> Option<(&dyn hpke::Hpke, hpke::HpkePublicKey)> {
+    ) -> Option<(&'static dyn hpke::Hpke, hpke::HpkePublicKey)> {
         let num_suites = self.suites.len();
         if num_suites == 0 {
             return None;

librustls/src/error.rs

@@ -42,7 +42,6 @@ macro_rules! ResultFromU32 {
 }
 
 /// Numeric error codes returned from rustls-ffi API functions.
-#[allow(dead_code)]
 #[repr(u32)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, ResultFromU32!)]
 pub enum rustls_result {