feat: allow compiling on the ESP32

pulsastrix · pulsastrix · commit b6d57b46f793 · 2024-06-14T17:36:19.000+02:00
diff --git a/libcoap-sys/Cargo.toml b/libcoap-sys/Cargo.toml
@@ -70,11 +70,20 @@ mbedtls-sys-auto = {version = "^2.26", optional = true}
 libc = "^0.2.126"
 tinydtls-sys = {version = "^0.2.0", default-features = false, optional = true}
 
+[target.'cfg(target_os="espidf")'.dependencies]
+esp-idf-sys = { version = "0.34.1"}
+
 [build-dependencies]
-bindgen = "^0.69.4"
+bindgen = "^0.63"
 autotools = "^0.2.3"
 fs_extra = "^1.2"
 pkg-config = "^0.3.24"
+regex = "1.10.5"
+embuild = { version = "0.31.3", features = ["bindgen", "espidf", "cmake"]}
 
 [package.metadata.docs.rs]
 features = ["dtls", "dtls_backend_openssl", "vendored"]
+
+[[package.metadata.esp-idf-sys.extra_components]]
+remote_component = { name = "espressif/coap", version = "4.3.4~3"}
+bindings_header = "src/wrapper.h"
diff --git a/libcoap-sys/build.rs b/libcoap-sys/build.rs
@@ -37,13 +37,105 @@ impl ToString for DtlsBackend {
     }
 }
 
+fn get_builder_espidf() -> bindgen::Builder {
+        embuild::espidf::sysenv::output();
+        let esp_idf_path = embuild::espidf::sysenv::idf_path().ok_or("missing IDF path").unwrap();
+        let esp_idf_buildroot  = env::var("DEP_ESP_IDF_ROOT").unwrap();
+        let esp_include_path = embuild::espidf::sysenv::cincl_args().ok_or("missing IDF cincl args").unwrap();
+        let embuild_env = embuild::espidf::sysenv::env_path().ok_or("missing IDF env path").unwrap();
+        let esp_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
+        let cfg_flags = embuild::espidf::sysenv::cfg_args().ok_or("missing cfg flags from IDF").unwrap();
+        
+        // Determine compiler path
+        env::set_var("PATH", &embuild_env);
+        let cmake_info = embuild::cmake::Query::new(
+            &Path::new(&esp_idf_buildroot).join("build"),
+            "cargo",
+            &[embuild::cmake::file_api::ObjKind::Codemodel, embuild::cmake::file_api::ObjKind::Toolchains, embuild::cmake::file_api::ObjKind::Cache],
+        ).unwrap().get_replies().unwrap();
+        let compiler = cmake_info
+            .get_toolchains().map_err(|_e| "Can't get toolchains")
+            .and_then(|mut t| {
+                t.take(embuild::cmake::file_api::codemodel::Language::C)
+                    .ok_or("No C toolchain")
+            })
+            .and_then(|t| {
+                t.compiler
+                    .path
+                    .ok_or("No compiler path set")
+            }).unwrap();
+
+        // Parse include arguments
+        let arg_splitter = regex::Regex::new(r##"(?:[^\\]"[^"]*[^\\]")?(\s)"##).unwrap();
+        let apostrophe_remover = regex::Regex::new(r##"^"(?<content>.*)"$"##).unwrap();
+        let esp_clang_args = arg_splitter.split(
+            esp_include_path.args.as_str()
+        ).map(|x| apostrophe_remover.replace(x.trim(), "$content").to_string()).collect::<Vec<String>>();
+        let bindgen_builder = embuild::bindgen::Factory {
+            clang_args: esp_clang_args.clone(),
+            linker: Some(compiler),
+            mcu: None,
+            force_cpp: false,
+            sysroot: None
+        }.builder().unwrap();
+
+        let clang_target = if esp_arch.starts_with("riscv32") {"riscv32"} else {esp_arch.as_str()};
+        let short_target = if esp_arch.starts_with("riscv32") {"riscv"} else {esp_arch.as_str()};
+        let target_mcu = if cfg_flags.get("esp32").is_some() {"esp32"}
+            else if cfg_flags.get("esp32s2").is_some() { "esp32s2" }
+            else if cfg_flags.get("esp32s3").is_some() { "esp32s3" }
+            else if cfg_flags.get("esp32c3").is_some() { "esp32c3" }
+            else if cfg_flags.get("esp32c2").is_some() { "esp32c2" }
+            else if cfg_flags.get("esp32h2").is_some() { "esp32h2" }
+            else if cfg_flags.get("esp32c5").is_some() { "esp32c5" }
+            else if cfg_flags.get("esp32c6").is_some() { "esp32c6" }
+            else if cfg_flags.get("esp32p4").is_some() { "esp32p4" }
+            else {panic!("unknown ESP target MCU, please add target to libcoap-sys build.rs file!")};
+        
+        return bindgen_builder
+            .clang_args(&esp_clang_args)
+            .clang_arg("-target")
+            .clang_arg(clang_target)
+            .clang_arg("-DESP_PLATFORM")
+            .clang_arg("-DLWIP_IPV4=1")
+            .clang_arg("-DLWIP_IPV6=1")
+            .clang_arg(format!("-I{}/components/lwip/lwip/src/include", esp_idf_path))
+            .clang_arg(format!("-I{}/components/lwip/port/freertos/include", esp_idf_path))
+            .clang_arg(format!("-I{}/components/esp_system/include", esp_idf_path))
+            .clang_arg(format!("-I{}/components/freertos/esp_additions/include", esp_idf_path))
+            .clang_arg(format!("-I{}/components/freertos/esp_additions/include/freertos", esp_idf_path))
+            .clang_arg(format!("-I{}/components/freertos/esp_additions/arch/{}/include", esp_idf_path, short_target)) // for older espidf
+            .clang_arg(format!("-I{}/components/freertos/config/{}/include", esp_idf_path, short_target)) // for newer espidf
+            .clang_arg(format!("-I{}/components/{}/include", esp_idf_path, short_target))
+            .clang_arg(format!("-I{}/components/freertos/FreeRTOS-Kernel-SMP/include", esp_idf_path))
+            .clang_arg(format!("-I{}/components/freertos/FreeRTOS-Kernel-SMP/portable/{}/include/freertos", esp_idf_path, short_target))
+            .clang_arg(format!("-I{}/components/soc/{}/include", esp_idf_path, target_mcu))
+            .clang_arg(format!("-I{}/components/heap/include", esp_idf_path))
+            .clang_arg(format!("-I{}/components/esp_rom/include", esp_idf_path))
+            .clang_arg(format!("-I{}/managed_components/espressif__coap/libcoap/include", esp_idf_buildroot))
+            .clang_arg(format!("-I{}/build/config/", esp_idf_buildroot))
+            .allowlist_type("epoll_event");
+}
+
+fn get_builder() -> bindgen::Builder {
+    bindgen::Builder::default()
+        .blocklist_type("epoll_event")
+}
+
 fn main() {
     println!("cargo:rerun-if-changed=src/libcoap/");
     println!("cargo:rerun-if-changed=src/wrapper.h");
-    let mut bindgen_builder = bindgen::Builder::default();
     // Read required environment variables.
     let orig_pkg_config = std::env::var_os("PKG_CONFIG_PATH").map(|v| String::from(v.to_str().unwrap()));
     let out_dir = env::var_os("OUT_DIR").unwrap();
+    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
+
+    let mut bindgen_builder = match target_os.as_str() {
+        "espidf" => get_builder_espidf(),
+        _ => get_builder()
+    };
+
+    
 
     let mut dtls_backend = Option::None;
     if cfg!(feature = "dtls") {
@@ -86,7 +178,7 @@ fn main() {
     }
 
     // Build vendored library if feature was set.
-    if cfg!(feature = "vendored") {
+    if cfg!(feature = "vendored") && target_os.as_str() != "espidf" {
         let libcoap_src_dir = Path::new(&out_dir).join("libcoap");
         // Read Makeflags into vector of strings
         //let make_flags: Vec<String> = std::env::var_os("CARGO_MAKEFLAGS")
@@ -275,72 +367,74 @@ fn main() {
         env::set_current_dir(current_dir_backup).expect("unable to switch back to source dir");
     }
 
-    // Tell cargo to link libcoap.
-    println!(
-        "cargo:rustc-link-lib={}{}",
-        cfg!(feature = "static").then(|| "static=").unwrap_or("dylib="),
-        format!(
-            "coap-3-{}",
-            &dtls_backend
-                .as_ref()
-                .map(|v| v.to_string())
-                .unwrap_or_else(|| "notls".to_string())
-        )
-        .as_str()
-    );
+    if target_os.as_str() != "espidf" {
+        // Tell cargo to link libcoap.
+        println!(
+            "cargo:rustc-link-lib={}{}",
+            cfg!(feature = "static").then(|| "static=").unwrap_or("dylib="),
+            format!(
+                "coap-3-{}",
+                &dtls_backend
+                    .as_ref()
+                    .map(|v| v.to_string())
+                    .unwrap_or_else(|| "notls".to_string())
+            )
+            .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.
-    if let Some(dtls_backend) = dtls_backend {
-        match dtls_backend {
-            DtlsBackend::TinyDtls => {
-                // Handled by tinydtls-sys
-            },
-            DtlsBackend::OpenSsl => {
-                // Handled by openssl-sys
-            },
-            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
-                    // mbedtls >= 3.0.0), so we need to tell cargo to link to mbedtls ourselves.
+        // 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.
+        if let Some(dtls_backend) = dtls_backend {
+            match dtls_backend {
+                DtlsBackend::TinyDtls => {
+                    // Handled by tinydtls-sys
+                },
+                DtlsBackend::OpenSsl => {
+                    // Handled by openssl-sys
+                },
+                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
+                        // mbedtls >= 3.0.0), so we need to tell cargo to link to mbedtls ourselves.
 
-                    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=")
-                        );
+                        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=")
+                            );
+                        }
                     }
-                }
-            },
-            DtlsBackend::GnuTls => {
-                // gnutls-sys is unmaintained, so we need to link to gnutls ourselves.
+                },
+                DtlsBackend::GnuTls => {
+                    // gnutls-sys is unmaintained, so we need to link to gnutls ourselves.
 
-                // try pkg-config
-                if probe_library("gnutls").is_err() {
-                    // if that doesn't work, try using the standard library search path.
-                    println!("cargo:rustc-link-lib=gnutls")
-                }
-            },
+                    // try pkg-config
+                    if probe_library("gnutls").is_err() {
+                        // if that doesn't work, try using the standard library search path.
+                        println!("cargo:rustc-link-lib=gnutls")
+                    }
+                },
+            }
         }
     }
 
     bindgen_builder = bindgen_builder
         .header("src/wrapper.h")
         .default_enum_style(EnumVariation::Rust { non_exhaustive: true })
-        .formatter(bindgen::Formatter::None)
+        .rustfmt_bindings(false)
         // Causes invalid syntax for some reason, so we have to disable it.
         .generate_comments(false)
         .dynamic_link_require_all(true)
@@ -353,7 +447,6 @@ fn main() {
         // We use the definitions made by the libc crate instead
         .blocklist_type("sockaddr(_in|_in6)?")
         .blocklist_type("in6?_(addr|port)(_t)?")
-        .blocklist_type("epoll_event")
         .blocklist_type("in6_addr__bindgen_ty_1")
         .blocklist_type("(__)?socklen_t")
         .blocklist_type("fd_set")
diff --git a/libcoap-sys/src/lib.rs b/libcoap-sys/src/lib.rs
@@ -86,9 +86,9 @@
 #![allow(deref_nullptr)]
 #![allow(non_snake_case)]
 
-use libc::{epoll_event, fd_set, sockaddr, sockaddr_in, sockaddr_in6, socklen_t, time_t, sa_family_t};
-
-use crate::coap_pdu_type_t::COAP_MESSAGE_RST;
+use libc::{fd_set, sockaddr, sockaddr_in, sockaddr_in6, socklen_t, time_t, sa_family_t};
+#[cfg(not(target_os = "espidf"))]
+use libc::{epoll_event};
 
 // use dtls backend libraries in cases where they set our linker flags, otherwise cargo will 
 // optimize them out.
@@ -104,7 +104,16 @@ include!(concat!(env!("OUT_DIR"), "\\bindings.rs"));
 #[cfg(not(target_family = "windows"))]
 include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 
-#[cfg(test)]
+#[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, crate::coap_pdu_type_t::COAP_MESSAGE_RST)
+}
+
+#[cfg(all(test, not(feature = "esp")))]
 mod tests {
     use std::{
         ffi::c_void,
diff --git a/libcoap/Cargo.toml b/libcoap/Cargo.toml
@@ -27,14 +27,14 @@ dtls_openssl_vendored = ["dtls_openssl", "libcoap-sys/dtls_backend_openssl_vendo
 dtls_gnutls = ["libcoap-sys/dtls_backend_gnutls"]
 dtls_mbedtls = ["libcoap-sys/dtls_backend_mbedtls"]
 dtls_mbedtls_vendored = ["dtls_mbedtls", "libcoap-sys/dtls_backend_mbedtls_vendored"]
-tcp = []
+tcp = ["libcoap-sys/tcp"]
 nightly = []
 vendored = ["libcoap-sys/vendored"]
 
 [dependencies]
-libcoap-sys = { version = "^0.2.2", path = "../libcoap-sys" }
+libcoap-sys = { version = "^0.2.2", path = "../libcoap-sys", default-features = false, features = ["client", "server"] }
 libc = { version = "^0.2.95" }
-num-derive = { version = "^0.3.3" }
+num-derive = { version = "^0.3.3" } 
 num-traits = { version = "^0.2.14" }
 url = { version = "^2.2" }
 rand = { version = "^0.8.4" }
diff --git a/libcoap/src/context.rs b/libcoap/src/context.rs
@@ -110,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 u32);
+            coap_context_set_block_mode(raw_context, (COAP_BLOCK_USE_LIBCOAP | COAP_BLOCK_SINGLE_BODY) as u8);
             coap_register_response_handler(raw_context, Some(session_response_handler));
         }
         let inner = CoapLendableFfiRcCell::new(CoapContextInner {
diff --git a/libcoap/src/resource.rs b/libcoap/src/resource.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_send_rst(raw_session, raw_incoming_pdu, COAP_MESSAGE_RST);
             Err(v1.and(v2).err().unwrap())
         },
     }
diff --git a/libcoap/src/types.rs b/libcoap/src/types.rs
@@ -128,14 +128,23 @@ impl From<SocketAddr> for CoapAddress {
                         size: std::mem::size_of::<sockaddr_in>() as socklen_t,
                         addr: std::mem::zeroed(),
                     };
+
                     *coap_addr.addr.sin.as_mut() = sockaddr_in {
+                        #[cfg(any(
+                            bsd,
+                            target_os = "aix",
+                            target_os = "haiku",
+                            target_os = "hurd",
+                            target_os = "espidf",
+                        ))]                            
+                        sin_len: (std::mem::size_of::<sockaddr_in>() as u8),
                         sin_family: AF_INET as sa_family_t,
                         sin_port: addr.port().to_be(),
                         sin_addr: in_addr {
                             s_addr: u32::from_ne_bytes(addr.ip().octets()),
                         },
                         sin_zero: Default::default(),
-                    };
+                    };                    
                     CoapAddress(coap_addr)
                 }
             },
@@ -148,7 +157,16 @@ impl From<SocketAddr> for CoapAddress {
                         size: std::mem::size_of::<sockaddr_in6>() as socklen_t,
                         addr: std::mem::zeroed(),
                     };
+                    
                     *coap_addr.addr.sin6.as_mut() = sockaddr_in6 {
+                        #[cfg(any(
+                            bsd,
+                            target_os = "aix",
+                            target_os = "haiku",
+                            target_os = "hurd",
+                            target_os = "espidf",
+                        ))]                        
+                        sin6_len: (std::mem::size_of::<sockaddr_in6>() as u8),
                         sin6_family: AF_INET6 as sa_family_t,
                         sin6_port: addr.port().to_be(),
                         sin6_addr: in6_addr {
@@ -157,6 +175,7 @@ impl From<SocketAddr> for CoapAddress {
                         sin6_flowinfo: addr.flowinfo(),
                         sin6_scope_id: addr.scope_id(),
                     };
+                    
                     CoapAddress(coap_addr)
                 }
             },

Original file line number	Diff line number	Diff line change
`@@ -110,7 +110,7 @@ impl<'a> CoapContext<'a> {`
`110`	`110`	`}`
`111`	`111`	`// SAFETY: We checked that raw_context is not null.`
`112`	`112`	`unsafe {`
`113`		`- coap_context_set_block_mode(raw_context, (COAP_BLOCK_USE_LIBCOAP \| COAP_BLOCK_SINGLE_BODY) as u32);`
	`113`	`+ coap_context_set_block_mode(raw_context, (COAP_BLOCK_USE_LIBCOAP \| COAP_BLOCK_SINGLE_BODY) as u8);`
`114`	`114`	`coap_register_response_handler(raw_context, Some(session_response_handler));`
`115`	`115`	`}`
`116`	`116`	`let inner = CoapLendableFfiRcCell::new(CoapContextInner {`
Original file line number	Diff line number	Diff line change
`@@ -95,7 +95,7 @@ pub unsafe fn prepare_resource_handler_data<'a, D: Any + ?Sized + Debug>(`
`95`	`95`	`match (request, response) {`
`96`	`96`	`(Ok(request), Ok(response)) => Ok((resource, session, request, response)),`
`97`	`97`	`(v1, v2) => {`
`98`		`- coap_send_rst(raw_session, raw_incoming_pdu);`
	`98`	`+ coap_send_rst(raw_session, raw_incoming_pdu, COAP_MESSAGE_RST);`
`99`	`99`	`Err(v1.and(v2).err().unwrap())`
`100`	`100`	`},`
`101`	`101`	`}`