fix: replace std to core and add config out

Author: JyJyJcr

nginx-sys/build/main.rs

@@ -97,6 +97,7 @@ fn generate_binding(nginx_build_dir: PathBuf) {
         .header("build/wrapper.h")
         .clang_args(clang_args)
         .layout_tests(false)
+        .use_core()
         .generate()
         .expect("Unable to generate bindings");
 

nginx-sys/src/lib.rs

@@ -1,9 +1,10 @@
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
+#![no_std]
 
-use std::fmt;
-use std::ptr::copy_nonoverlapping;
-use std::slice;
+use core::fmt;
+use core::ptr::copy_nonoverlapping;
+use core::slice;
 
 #[doc(hidden)]
 mod bindings {
@@ -104,7 +105,7 @@ impl ngx_str_t {
     /// # Returns
     /// A string slice (`&str`) representing the nginx string.
     pub fn to_str(&self) -> &str {
-        std::str::from_utf8(self.as_bytes()).unwrap()
+        core::str::from_utf8(self.as_bytes()).unwrap()
     }
 
     /// Create an `ngx_str_t` instance from a byte slice.
@@ -147,26 +148,29 @@ impl From<ngx_str_t> for &[u8] {
     }
 }
 
-impl TryFrom<ngx_str_t> for String {
-    type Error = std::string::FromUtf8Error;
-
-    fn try_from(s: ngx_str_t) -> Result<Self, Self::Error> {
-        let bytes: &[u8] = s.into();
-        String::from_utf8(bytes.into())
-    }
-}
-
 impl fmt::Display for ngx_str_t {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", String::from_utf8_lossy((*self).into()))
+        // The implementation is similar to an inlined `String::from_utf8_lossy`, with two
+        // important differences:
+        //
+        //  - it writes directly to the Formatter instead of allocating a temporary String
+        //  - invalid sequences are represented as escaped individual bytes
+        for chunk in self.as_bytes().utf8_chunks() {
+            f.write_str(chunk.valid())?;
+            for byte in chunk.invalid() {
+                f.write_str("\\x")?;
+                fmt::LowerHex::fmt(byte, f)?;
+            }
+        }
+        Ok(())
     }
 }
 
 impl TryFrom<ngx_str_t> for &str {
-    type Error = std::str::Utf8Error;
+    type Error = core::str::Utf8Error;
 
     fn try_from(s: ngx_str_t) -> Result<Self, Self::Error> {
-        std::str::from_utf8(s.into())
+        core::str::from_utf8(s.into())
     }
 }
 
@@ -219,7 +223,8 @@ pub unsafe fn add_to_ngx_table(
 
 #[cfg(test)]
 mod tests {
-    use std::string::ToString;
+    extern crate alloc;
+    use alloc::string::ToString;
 
     use super::*;
 

src/core/buffer.rs

@@ -1,4 +1,4 @@
-use std::slice;
+use core::slice;
 
 use crate::ffi::*;
 

src/core/mod.rs

@@ -22,7 +22,7 @@ macro_rules! ngx_null_command {
             set: None,
             conf: 0,
             offset: 0,
-            post: ::std::ptr::null_mut(),
+            post: ::core::ptr::null_mut(),
         }
     };
 }

src/core/pool.rs

@@ -1,5 +1,5 @@
-use std::ffi::c_void;
-use std::{mem, ptr};
+use core::ffi::c_void;
+use core::{mem, ptr};
 
 use crate::core::buffer::{Buffer, MemoryBuffer, TemporaryBuffer};
 use crate::ffi::*;

src/core/status.rs

@@ -1,4 +1,4 @@
-use std::fmt;
+use core::fmt;
 
 use crate::ffi::*;
 

src/core/string.rs

@@ -1,6 +1,10 @@
-use std::borrow::Cow;
-use std::slice;
-use std::str::{self, Utf8Error};
+use core::slice;
+use core::str::{self, Utf8Error};
+
+#[cfg(all(not(feature = "std"), feature = "alloc"))]
+use alloc::{borrow::Cow, string::String};
+#[cfg(feature = "std")]
+use std::{borrow::Cow, string::String};
 
 use crate::ffi::*;
 
@@ -27,7 +31,7 @@ macro_rules! ngx_null_string {
     () => {
         $crate::ffi::ngx_str_t {
             len: 0,
-            data: ::std::ptr::null_mut(),
+            data: ::core::ptr::null_mut(),
         }
     };
 }
@@ -64,6 +68,7 @@ impl NgxStr {
     /// Converts an [`NgxStr`] into a [`Cow<str>`], replacing invalid UTF-8 sequences.
     ///
     /// See [`String::from_utf8_lossy`].
+    #[cfg(feature = "alloc")]
     pub fn to_string_lossy(&self) -> Cow<str> {
         String::from_utf8_lossy(self.as_bytes())
     }

src/http/conf.rs

@@ -1,4 +1,4 @@
-use std::ffi::c_void;
+use core::ffi::c_void;
 
 use crate::ffi::*;
 

src/http/module.rs

@@ -1,5 +1,6 @@
-use std::ffi::{c_char, c_void};
-use std::ptr;
+use core::ffi::{c_char, c_void};
+use core::fmt;
+use core::ptr;
 
 use crate::core::NGX_CONF_ERROR;
 use crate::core::*;
@@ -12,10 +13,11 @@ pub enum MergeConfigError {
     NoValue,
 }
 
+#[cfg(feature = "std")]
 impl std::error::Error for MergeConfigError {}
 
-impl std::fmt::Display for MergeConfigError {
-    fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl fmt::Display for MergeConfigError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         match self {
             MergeConfigError::NoValue => "no value".fmt(fmt),
         }

src/http/request.rs

@@ -1,8 +1,7 @@
+use core::ffi::c_void;
+use core::fmt;
 use core::slice;
-use std::error::Error;
-use std::ffi::c_void;
-use std::fmt;
-use std::str::FromStr;
+use core::str::FromStr;
 
 use crate::core::*;
 use crate::ffi::*;
@@ -31,7 +30,7 @@ macro_rules! http_subrequest_handler {
     ( $name: ident, $handler: expr ) => {
         unsafe extern "C" fn $name(
             r: *mut $crate::ffi::ngx_http_request_t,
-            data: *mut ::std::ffi::c_void,
+            data: *mut ::core::ffi::c_void,
             rc: $crate::ffi::ngx_int_t,
         ) -> $crate::ffi::ngx_int_t {
             $handler(r, data, rc)
@@ -117,7 +116,7 @@ impl Request {
     /// Is this the main request (as opposed to a subrequest)?
     pub fn is_main(&self) -> bool {
         let main = self.0.main.cast();
-        std::ptr::eq(self, main)
+        core::ptr::eq(self, main)
     }
 
     /// Request pool.
@@ -338,7 +337,7 @@ impl Request {
                 ngx_http_internal_redirect(
                     (self as *const Request as *mut Request).cast(),
                     uri_ptr,
-                    std::ptr::null_mut(),
+                    core::ptr::null_mut(),
                 );
             }
         }
@@ -355,7 +354,7 @@ impl Request {
         let uri_ptr = unsafe { &mut ngx_str_t::from_str(self.0.pool, uri) as *mut _ };
         // -------------
         // allocate memory and set values for ngx_http_post_subrequest_t
-        let sub_ptr = self.pool().alloc(std::mem::size_of::<ngx_http_post_subrequest_t>());
+        let sub_ptr = self.pool().alloc(core::mem::size_of::<ngx_http_post_subrequest_t>());
 
         // assert!(sub_ptr.is_null());
         let post_subreq = sub_ptr as *const ngx_http_post_subrequest_t as *mut ngx_http_post_subrequest_t;
@@ -365,12 +364,12 @@ impl Request {
         }
         // -------------
 
-        let mut psr: *mut ngx_http_request_t = std::ptr::null_mut();
+        let mut psr: *mut ngx_http_request_t = core::ptr::null_mut();
         let r = unsafe {
             ngx_http_subrequest(
                 (self as *const Request as *mut Request).cast(),
                 uri_ptr,
-                std::ptr::null_mut(),
+                core::ptr::null_mut(),
                 &mut psr as *mut _,
                 sub_ptr as *mut _,
                 NGX_HTTP_SUBREQUEST_WAITED as _,
@@ -384,7 +383,7 @@ impl Request {
          * allocate fake request body to avoid attempts to read it and to make
          * sure real body file (if already read) won't be closed by upstream
          */
-        sr.request_body = self.pool().alloc(std::mem::size_of::<ngx_http_request_body_t>()) as *mut _;
+        sr.request_body = self.pool().alloc(core::mem::size_of::<ngx_http_request_body_t>()) as *mut _;
 
         if sr.request_body.is_null() {
             return Status::NGX_ERROR;
@@ -710,7 +709,8 @@ impl fmt::Display for InvalidMethod {
     }
 }
 
-impl Error for InvalidMethod {}
+#[cfg(feature = "std")]
+impl std::error::Error for InvalidMethod {}
 
 #[derive(Clone, PartialEq, Eq, Hash)]
 enum MethodInner {