Try #252:

Author: bors[bot]

Cargo.lock

@@ -1,2 +1,10 @@
 [workspace]
 members = ["mbedtls", "mbedtls-sys"]
+
+[patch.crates-io]
+# This patch resolves a local dependency conflict between `mbedtls` and `mbedtls-selftest`.
+# Both of these crates require the native library `mbedtls-sys-auto`.
+# By default, Cargo chooses the `mbedtls-sys-auto` version from crates.io for `mbedtls-selftest`,
+# which conflicts with the local `mbedtls-sys-auto` used by `mbedtls`.
+# This patch ensures the local `mbedtls-sys-auto` is used for both crates.
+mbedtls-sys-auto = { path = "./mbedtls-sys" }

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mbedtls"
-version = "0.8.2"
+version = "0.8.3"
 authors = ["Jethro Beekman <[email protected]>"]
 build = "build.rs"
 edition = "2018"
@@ -38,9 +38,12 @@ chrono = "0.4"
 [dependencies.mbedtls-sys-auto]
 version = "2.25.0"
 default-features = false
-features = ["custom_printf", "trusted_cert_callback", "threading"]
+features = ["trusted_cert_callback", "threading"]
 path = "../mbedtls-sys"
 
+[dependencies.mbedtls-selftest]
+version = "0.1"
+
 [dev-dependencies]
 libc = "0.2.0"
 rand = "0.4.0"
@@ -55,7 +58,7 @@ cc = "1.0"
 [features]
 # Features are documented in the README
 default = ["std", "aesni", "time", "padlock"]
-std = ["mbedtls-sys-auto/std", "serde/std", "yasna"]
+std = ["mbedtls-sys-auto/std", "serde/std", "yasna", "mbedtls-selftest/std"]
 debug = ["mbedtls-sys-auto/debug"]
 no_std_deps = ["core_io", "spin"]
 force_aesni_support = ["mbedtls-sys-auto/custom_has_support", "mbedtls-sys-auto/aes_alt", "aesni"]

mbedtls/Cargo.toml

@@ -9,7 +9,23 @@
 use std::collections::{HashMap, HashSet};
 use std::env;
 
+/// Return the crate hash that Cargo will be passing to `rustc -C metadata=`.
+// If there's a panic in this code block, that means Cargo's way of running the
+// build script has changed, and this code should be updated to handle the new
+// case.
+fn get_compilation_metadata_hash() -> String {
+    let out_dir: std::path::PathBuf = std::env::var_os("OUT_DIR").unwrap().into();
+    let mut out_dir_it = out_dir.iter().rev();
+    assert_eq!(out_dir_it.next().unwrap(), "out");
+    let crate_ = out_dir_it.next().unwrap().to_string_lossy();
+    assert!(crate_.starts_with("mbedtls-"));
+    crate_[8..].to_owned()
+}
+
 fn main() {
+    let metadata_hash = get_compilation_metadata_hash();
+    println!("cargo:rustc-env=RUST_MBEDTLS_METADATA_HASH={}", metadata_hash);
+
     let env_components = env::var("DEP_MBEDTLS_PLATFORM_COMPONENTS").unwrap();
     let mut sys_platform_components = HashMap::<_, HashSet<_>>::new();
     for mut kv in env_components.split(",").map(|component| component.splitn(2, "=")) {
@@ -24,17 +40,13 @@ fn main() {
     let config_file = format!(r#""{}""#, env::var("DEP_MBEDTLS_CONFIG_H").unwrap());
     b.define("MBEDTLS_CONFIG_FILE",
              Some(config_file.as_str()));
+    b.define("RUST_MBEDTLS_METADATA_HASH", Some(metadata_hash.as_str()));
 
     b.file("src/mbedtls_malloc.c");
-    b.file("src/rust_printf.c");
     if sys_platform_components.get("c_compiler").map_or(false, |comps| comps.contains("freestanding")) {
         b.flag("-U_FORTIFY_SOURCE")
             .define("_FORTIFY_SOURCE", Some("0"))
             .flag("-ffreestanding");
     }
     b.compile("librust-mbedtls.a");
-    // Force correct link order for mbedtls_printf
-    println!("cargo:rustc-link-lib=static=mbedtls");
-    println!("cargo:rustc-link-lib=static=mbedx509");
-    println!("cargo:rustc-link-lib=static=mbedcrypto");
 }

mbedtls/build.rs

@@ -15,7 +15,10 @@ use core::mem::ManuallyDrop;
 use mbedtls_sys::types::raw_types::c_void;
 
 extern "C" {
-    pub(crate) fn forward_mbedtls_free(n: *mut mbedtls_sys::types::raw_types::c_void);
+    #[link_name = concat!("\u{1}forward_mbedtls_free_", env!("RUST_MBEDTLS_METADATA_HASH"))]
+    pub(crate) fn mbedtls_free(n: *mut mbedtls_sys::types::raw_types::c_void);
+    #[link_name = concat!("\u{1}forward_mbedtls_calloc_", env!("RUST_MBEDTLS_METADATA_HASH"))]
+    pub(crate) fn mbedtls_calloc(n: mbedtls_sys::types::size_t, size: mbedtls_sys::types::size_t) -> *mut mbedtls_sys::types::raw_types::c_void;
 }
 
 #[repr(transparent)]
@@ -53,13 +56,15 @@ impl<T> Drop for Box<T> {
     fn drop(&mut self) {
         unsafe {
             drop_in_place(self.inner.as_ptr());
-            forward_mbedtls_free(self.inner.as_ptr() as *mut c_void)
+            mbedtls_free(self.inner.as_ptr() as *mut c_void)
         }
     }
 }
 
+unsafe impl<T: Send> Send for Box<T> {}
+unsafe impl<T: Sync> Sync for Box<T> {}
+
 #[repr(transparent)]
 pub struct List<T> {
     pub(crate) inner: Option<Box<T>>
 }
-

mbedtls/src/alloc.rs

@@ -38,7 +38,7 @@ pub mod ecp;
 pub mod hash;
 pub mod pk;
 pub mod rng;
-pub mod self_test;
+pub use mbedtls_selftest as self_test;
 pub mod ssl;
 pub mod x509;
 pub mod alloc;
@@ -158,3 +158,69 @@ cfg_if::cfg_if! {
 pub unsafe fn set_global_debug_threshold(threshold: i32) {
     mbedtls_sys::debug_set_threshold(threshold);
 }
+
+#[cfg(test)]
+mod tests {
+    #[allow(dead_code)]
+    /// Utilities for testing whether types implement certain traits.
+    ///
+    /// For each trait `Trait` that you want to be able to test, you should
+    /// implement:
+    /// ```ignore
+    /// impl<T: “Trait”> Testable<dyn “Trait”> for T {}
+    /// ```
+    ///
+    /// Then, to test whether a type `Type` implements `Trait`, call:
+    /// ```ignore
+    /// TestTrait::<dyn “Trait”, “Type”>::new().impls_trait()
+    /// ```
+    /// This returns a `bool` indicating whether the trait is implemented.
+    // This relies on auto-deref to distinguish between types that do and don't
+    // implement the trait.
+    mod testtrait {
+        use core::marker::PhantomData;
+
+        pub struct NonImplTrait<T> {
+            inner: PhantomData<T>
+        }
+
+        pub struct TestTrait<TraitObj: ?Sized, Type> {
+            non_impl: NonImplTrait<Type>,
+            phantom: PhantomData<*const TraitObj>,
+        }
+
+        pub trait Testable<T: ?Sized> {}
+
+        impl<TraitObj: ?Sized, Type> TestTrait<TraitObj, Type> {
+            pub fn new() -> Self {
+                TestTrait { non_impl: NonImplTrait { inner: PhantomData }, phantom: PhantomData }
+            }
+        }
+
+        impl<TraitObj: ?Sized, Type: Testable<TraitObj>> TestTrait<TraitObj, Type> {
+            pub fn impls_trait(&self) -> bool {
+                true
+            }
+        }
+
+        impl<T> NonImplTrait<T> {
+            pub fn impls_trait(&self) -> bool {
+                false
+            }
+        }
+
+        impl<TraitObj: ?Sized, Type> core::ops::Deref for TestTrait<TraitObj, Type> {
+            type Target = NonImplTrait<Type>;
+
+            fn deref(&self) -> &NonImplTrait<Type> {
+                &self.non_impl
+            }
+        }
+    }
+
+    pub use testtrait::{TestTrait, Testable};
+
+    impl<T: Send> Testable<dyn Send> for T {}
+    impl<T: Sync> Testable<dyn Sync> for T {}
+    impl<T: Send + Sync> Testable<dyn Send + Sync> for T {}
+}

mbedtls/src/lib.rs

@@ -21,11 +21,15 @@
 #define mbedtls_free      free
 #endif
 
-extern void *forward_mbedtls_calloc( size_t n, size_t size ) {
+// Use several macros to get the preprocessor to actually replace RUST_MBEDTLS_METADATA_HASH
+#define append_macro_inner(a, b) a##_##b
+#define append_macro(a, b) append_macro_inner(a, b)
+#define APPEND_METADATA_HASH(f) append_macro(f, RUST_MBEDTLS_METADATA_HASH)
+
+extern void *APPEND_METADATA_HASH(forward_mbedtls_calloc)( size_t n, size_t size ) {
     return mbedtls_calloc(n, size);
 }
 
-extern void forward_mbedtls_free( void *ptr ) {
+extern void APPEND_METADATA_HASH(forward_mbedtls_free)( void *ptr ) {
     mbedtls_free(ptr);
 }
-

mbedtls/src/mbedtls_malloc.c

@@ -113,7 +113,7 @@ extern "C" fn alloc_custom_pk_ctx() -> *mut c_void {
 }
 
 unsafe extern "C" fn free_custom_pk_ctx(p: *mut c_void) {
-    Box::from_raw(p as *mut CustomPkContext);
+    let _ = Box::from_raw(p as *mut CustomPkContext);
 }
 
 extern "C" fn custom_pk_can_do(_t: u32) -> i32 {