fix: update libcoap to development state, allow setting mbedtls path

Author: pulsastrix

.idea/libcoap-rs.iml

@@ -61,6 +61,7 @@ fn main() {
             if dtls_backend.is_some() {
                 multiple_backends = true;
             }
+            println!("cargo:rerun-if-env-changed=MBEDTLS_LIBRARY_PATH");
             dtls_backend = Some(DtlsBackend::MbedTls);
         }
         if cfg!(feature = "dtls_backend_openssl") {
@@ -187,8 +188,28 @@ fn main() {
                             .unwrap()
                             .join("build")
                             .join("library");
-                        build_config.env("CFLAGS", format!("-I{}", mbedtls_include.to_str().unwrap()));
-                        build_config.env("LDFLAGS", format!("-L{}", mbedtls_library_path.to_str().unwrap()));
+                        build_config.env("MbedTLS_CFLAGS", format!("-I{}", mbedtls_include.to_str().unwrap()));
+                        build_config.env("MbedTLS_LIBS", format!("-lmbedtls -lmbedcrypto -lmbedx509 -L{}", mbedtls_library_path.to_str().unwrap()));
+                    } else {
+                        // If we're not vendoring mbedtls, allow manually setting the mbedtls
+                        // library path (required if linking statically, which is always the case
+                        // when vendoring libcoap).
+                        if let Some(mbedtls_lib_path) = env::var_os("MBEDTLS_LIBRARY_PATH") {
+                            build_config.env("MbedTLS_LIBS", format!("-lmbedtls -lmbedcrypto -lmbedx509 -L{}", mbedtls_lib_path.to_str().unwrap()));
+                            if let Some(mbedtls_include_path) = env::var_os("MBEDTLS_INCLUDE_PATH") {
+                                build_config.env("MbedTLS_CFLAGS", format!("-I{}", mbedtls_include_path.to_str().unwrap()));
+                            }
+                        } else {
+                            // mbedtls will get pkg-config support in the near future, prepare for that
+                            if let Ok(lib) = &pkg_config::Config::new().cargo_metadata(false).probe("mbedtls") {
+                                let mut lib_flags = "-lmbedtls -lmbedcrypto -lmbedx509".to_string();
+                                lib_flags.push_str(lib.link_paths.iter().map(|x| format!("-L{} ", x.display())).collect::<String>().as_str());
+                                build_config.env("MbedTLS_LIBS", lib_flags);
+                                build_config.env("MbedTLS_CFLAGS", lib.link_paths.iter().map(|x| format!("-I{}", x.display())).collect::<String>());
+                            } else {
+                                println!("cargo:warning=You have enabled libcoap vendoring with mbedtls, but haven't provided a static library path for mbedtls (MBEDTLS_LIBRARY_PATH environment variable is unset). Building might fail because of that.");
+                            }
+                        }
                     }
                 },
                 DtlsBackend::GnuTls => {
@@ -214,7 +235,9 @@ fn main() {
             // Disable tests and examples as well as test coverage
             .disable("tests", None)
             .disable("examples", None)
-            .disable("gcov", None);
+            .disable("gcov", None)
+            // TODO allow multithreaded access
+            .disable("thread-safe", None);
 
         // Enable debug symbols if enabled in Rust
         match std::env::var_os("DEBUG").unwrap().to_str().unwrap() {
@@ -255,7 +278,7 @@ fn main() {
     // Tell cargo to link libcoap.
     println!(
         "cargo:rustc-link-lib={}{}",
-        cfg!(feature = "static").then(|| "static=").unwrap_or(""),
+        cfg!(feature = "static").then(|| "static=").unwrap_or("dylib="),
         format!(
             "coap-3-{}",
             &dtls_backend
@@ -265,10 +288,10 @@ fn main() {
         )
         .as_str()
     );
-    
+
     // For the DTLS libraries, we need to tell cargo which external libraries to link.
     // Note that these linker instructions have to be added *after* the linker instruction
-    // for libcoap itself, as some linkers require dependencies to be in reverse order. 
+    // for libcoap itself, as some linkers require dependencies to be in reverse order.
     if let Some(dtls_backend) = dtls_backend {
         match dtls_backend {
             DtlsBackend::TinyDtls => {
@@ -280,15 +303,25 @@ fn main() {
             DtlsBackend::MbedTls => {
                 // If mbedtls is vendored, mbedtls-sys-auto already takes care of linking.
                 if env::var_os("DEP_MBEDTLS_INCLUDE").is_none() {
-                    // We aren't using mbedtls-sys-auto if we aren't vendoring (as it doesn't support 
+                    // We aren't using mbedtls-sys-auto if we aren't vendoring (as it doesn't support
                     // mbedtls >= 3.0.0), so we need to tell cargo to link to mbedtls ourselves.
-                    
-                    // Try to find mbedtls using pkg-config
-                    if probe_library("mbedtls").is_err() {
-                        // couldn't find using pkg-config, just try linking with default library search path
-                        println!("cargo:rustc-link-lib=mbedtls");
-                        println!("cargo:rustc-link-lib=mbedx509");
-                        println!("cargo:rustc-link-lib=mbedcrypto");
+
+                    if let Some(mbedtls_lib_path) = env::var_os("MBEDTLS_LIBRARY_PATH") {
+                        println!("cargo:rustc-link-search=native={}", mbedtls_lib_path.to_str().unwrap())
+                    }
+                    // Try to find mbedtls using pkg-config, will emit cargo link statements if successful
+                    if env::var_os("MBEDTLS_LIBRARY_PATH").is_some() || pkg_config::Config::new().statik(cfg!(feature = "static")).probe("mbedtls").is_err() {
+                        // couldn't find using pkg-config or MBEDTLS_LIBRARY_PATH was set, just try
+                        // linking with given library search path
+                        println!("cargo:rustc-link-lib={}mbedtls",
+                                 cfg!(feature = "static").then(|| "static=").unwrap_or("dylib=")
+                        );
+                        println!("cargo:rustc-link-lib={}mbedx509",
+                                 cfg!(feature = "static").then(|| "static=").unwrap_or("dylib=")
+                        );
+                        println!("cargo:rustc-link-lib={}mbedcrypto",
+                                 cfg!(feature = "static").then(|| "static=").unwrap_or("dylib=")
+                        );
                     }
                 }
             },

.idea/runConfigurations/Test.xml

@@ -104,15 +104,6 @@ include!(concat!(env!("OUT_DIR"), "\\bindings.rs"));
 #[cfg(not(target_family = "windows"))]
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 
-#[inline]
-pub unsafe fn coap_send_rst(
-    session: *mut coap_session_t,
-    request: *const coap_pdu_t,
-    _type_: coap_pdu_type_t,
-) -> coap_mid_t {
-    coap_send_message_type(session, request, COAP_MESSAGE_RST)
-}
-
 #[cfg(test)]
 mod tests {
     use std::{

.idea/vcs.xml

@@ -10,6 +10,7 @@
 //! Module containing context-internal types and traits.
 
 use std::{any::Any, ffi::c_void, fmt::Debug, marker::PhantomData, net::SocketAddr, ops::Sub, time::Duration};
+use std::sync::Once;
 
 use libc::c_uint;
 
@@ -22,8 +23,11 @@ use libcoap_sys::{
     coap_dtls_spsk_info_t, coap_dtls_spsk_t, coap_event_t, coap_free_context, coap_get_app_data, coap_io_process,
     coap_new_context, coap_proto_t, coap_register_event_handler, coap_register_response_handler, coap_set_app_data,
     COAP_BLOCK_SINGLE_BODY, COAP_BLOCK_USE_LIBCOAP, COAP_DTLS_SPSK_SETUP_VERSION, COAP_IO_WAIT,
+    coap_startup
 };
 
+static COAP_STARTUP_ONCE: Once = Once::new();
+
 #[cfg(feature = "dtls")]
 use crate::crypto::{dtls_server_id_callback, dtls_server_sni_callback, CoapServerCryptoProvider};
 #[cfg(feature = "dtls")]
@@ -94,6 +98,10 @@ impl<'a> CoapContext<'a> {
     /// Returns an error if the underlying libcoap library was unable to create a new context
     /// (probably an allocation error?).
     pub fn new() -> Result<CoapContext<'a>, ContextCreationError> {
+        // TODO this should actually be done before calling _any_ libcoap function, not just the
+        //      context initialization. Maybe we need to make sure to call this in other places too
+        //      (e.g. if a resource is initialized before a context is created).
+        COAP_STARTUP_ONCE.call_once(|| unsafe { coap_startup(); });
         // SAFETY: Providing null here is fine, the context will just not be bound to an endpoint
         // yet.
         let raw_context = unsafe { coap_new_context(std::ptr::null()) };
@@ -102,7 +110,7 @@ impl<'a> CoapContext<'a> {
         }
         // SAFETY: We checked that raw_context is not null.
         unsafe {
-            coap_context_set_block_mode(raw_context, (COAP_BLOCK_USE_LIBCOAP | COAP_BLOCK_SINGLE_BODY) as u8);
+            coap_context_set_block_mode(raw_context, (COAP_BLOCK_USE_LIBCOAP | COAP_BLOCK_SINGLE_BODY) as u32);
             coap_register_response_handler(raw_context, Some(session_response_handler));
         }
         let inner = CoapLendableFfiRcCell::new(CoapContextInner {

libcoap-sys/build.rs

@@ -95,7 +95,7 @@ pub unsafe fn prepare_resource_handler_data<'a, D: Any + ?Sized + Debug>(
     match (request, response) {
         (Ok(request), Ok(response)) => Ok((resource, session, request, response)),
         (v1, v2) => {
-            coap_send_rst(raw_session, raw_incoming_pdu, COAP_MESSAGE_RST);
+            coap_send_rst(raw_session, raw_incoming_pdu);
             Err(v1.and(v2).err().unwrap())
         },
     }

libcoap-sys/src/lib.rs

@@ -23,6 +23,7 @@ use libcoap_rs::{
     session::CoapSessionCommon,
     CoapContext,
 };
+use libcoap_sys::coap_startup;
 
 mod common;