feat: add std feature for opt-out

Author: JyJyJcr

Cargo.toml

@@ -25,12 +25,12 @@ repository.workspace = true
 rust-version.workspace = true
 
 [dependencies]
-nginx-sys = { path = "nginx-sys", version = "0.5.0"}
+nginx-sys = { path = "nginx-sys", default-features = false, version = "0.5.0" }
 
 [features]
 default = ["vendored","std"]
 # use std memory allocation
-std = []
+std = ["nginx-sys/std"]
 # Build our own copy of the NGINX by default.
 # This could be disabled with `--no-default-features` to minimize the dependency tree
 # when building against an existing copy of the NGINX with the NGX_OBJS variable.

nginx-sys/Cargo.toml

@@ -27,6 +27,6 @@ ureq = { version = "2.9.6", features = ["tls"], optional = true }
 which = { version = "6.0.0", optional = true }
 
 [features]
-default = ["std"]
+default = ["std","vendored"]
 std = []
 vendored = ["dep:which", "dep:duct", "dep:ureq", "dep:flate2", "dep:tar"]

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,5 +1,8 @@
 #![doc = include_str!("../README.md")]
 #![warn(missing_docs)]
+#![cfg_attr(not(feature = "std"), no_std)]
+#[cfg(not(feature = "std"))]
+extern crate alloc;
 
 use core::fmt;
 use core::ptr::copy_nonoverlapping;
@@ -17,6 +20,11 @@ mod bindings {
     #![allow(rustdoc::broken_intra_doc_links)]
     include!(concat!(env!("OUT_DIR"), "/bindings.rs"));
 }
+#[cfg(not(feature = "std"))]
+use alloc::string;
+#[cfg(feature = "std")]
+use std::string;
+
 #[doc(no_inline)]
 pub use bindings::*;
 
@@ -92,7 +100,7 @@ impl ngx_str_t {
         self.len == 0
     }
 
-    /// Convert the nginx string to a string slice (`&str`).
+    /// Returns the contents of this `ngx_str_t` as a string slice (`&str`).
     ///
     /// # Safety
     /// This function is marked as unsafe because it involves raw pointer manipulation.
@@ -107,6 +115,99 @@ impl ngx_str_t {
         core::str::from_utf8(self.as_bytes()).unwrap()
     }
 
+    // /// Returns the contents of this `ngx_str_t` as a mutable string slice (`&str`).
+    // ///
+    // /// # Safety
+    // /// This function is marked as unsafe because it involves raw pointer manipulation.
+    // /// It assumes that the underlying `data` pointer is valid and points to a valid UTF-8 encoded string.
+    // ///
+    // /// # Panics
+    // /// This function panics if the `ngx_str_t` is not valid UTF-8.
+    // ///
+    // /// # Returns
+    // /// A mutable string slice (`&mut str`) representing the nginx string.
+    // pub fn to_str_mut(&mut self) -> &str {
+    //     core::str::from_utf8(self.as_bytes()).unwrap()
+    // }
+
+    // /// Convert `ngx_str_t` to a byte slice.
+    // ///
+    // /// The returned slice will **not** contain the optional nul terminator that `ngx_str_t.data`
+    // /// may have.
+    // ///
+    // /// # Safety
+    // /// This function is marked as unsafe because it involves lifetime generation.
+    // /// Caller must specify the proper lifetime which original `ngx_str_t` belongs to.
+    // #[inline]
+    // pub fn into_bytes<'a>(self) -> &'a [u8] {
+    //     if self.is_empty() {
+    //         &[]
+    //     } else {
+    //         // SAFETY: `ngx_str_t` with non-zero len must contain a valid correctly aligned pointer
+    //         unsafe { slice::from_raw_parts(self.data, self.len) }
+    //     }
+    // }
+
+    // /// Convert `ngx_str_t` to a mutable byte slice.
+    // ///
+    // /// The returned slice will **not** contain the optional nul terminator that `ngx_str_t.data`
+    // /// may have.
+    // ///
+    // /// # Safety
+    // /// This function is marked as unsafe because it involves raw pointer manipulation.
+    // /// It assumes that the underlying `data` pointer is valid and points to a valid UTF-8 encoded string.
+    // ///
+    // /// This function is marked as unsafe because it involves lifetime generation.
+    // /// Caller must specify the proper lifetime which original `ngx_str_t` belongs to.
+    // ///
+    // /// # Panics
+    // /// This function panics if the `ngx_str_t` is not valid UTF-8.
+    // ///
+    // /// # Returns
+    // /// A mutable string slice (`&mut str`) representing the nginx string.
+    // #[inline]
+    // pub fn into_bytes_mut<'a>(self) -> &'a mut [u8] {
+    //     if self.is_empty() {
+    //         &mut []
+    //     } else {
+    //         // SAFETY: `ngx_str_t` with non-zero len must contain a valid correctly aligned pointer
+    //         unsafe { slice::from_raw_parts_mut(self.data, self.len) }
+    //     }
+    // }
+
+    // /// Convert `ngx_str_t` to a string slice (`&str`).
+    // ///
+    // /// The returned slice will **not** contain the optional nul terminator that `ngx_str_t.data`
+    // /// may have.
+    // ///
+    // /// # Safety
+    // /// This function is marked as unsafe because it involves lifetime generation.
+    // /// Caller must specify the proper lifetime which original `ngx_str_t` belongs to.
+    // pub fn into_str<'a>(self) -> &'a str {
+    //     core::str::from_utf8(self.into_bytes()).unwrap()
+    // }
+
+    // /// Convert `ngx_str_t` to a mutable byte string slice (`&str`).
+    // ///
+    // /// The returned slice will **not** contain the optional nul terminator that `ngx_str_t.data`
+    // /// may have.
+    // ///
+    // /// # Safety
+    // /// This function is marked as unsafe because it involves raw pointer manipulation.
+    // /// It assumes that the underlying `data` pointer is valid and points to a valid UTF-8 encoded string.
+    // ///
+    // /// This function is marked as unsafe because it involves lifetime generation.
+    // /// Caller must specify the proper lifetime which original `ngx_str_t` belongs to.
+    // ///
+    // /// # Panics
+    // /// This function panics if the `ngx_str_t` is not valid UTF-8.
+    // ///
+    // /// # Returns
+    // /// A mutable string slice (`&mut str`) representing the nginx string.
+    // pub fn into_str_mut<'a>(self) -> &'a mut str {
+    //     core::str::from_utf8_mut(self.into_bytes_mut()).unwrap()
+    // }
+
     /// Create an `ngx_str_t` instance from a byte slice.
     ///
     /// # Safety
@@ -130,7 +231,7 @@ impl ngx_str_t {
     ///
     /// # Returns
     /// An `ngx_str_t` instance representing the given `String`.
-    pub unsafe fn from_string(pool: *mut ngx_pool_t, data: String) -> Self {
+    pub unsafe fn from_string(pool: *mut ngx_pool_t, data: string::String) -> Self {
         ngx_str_t {
             data: str_to_uchar(pool, data.as_str()),
             len: data.len(),
@@ -168,19 +269,18 @@ impl From<ngx_str_t> for &[u8] {
     }
 }
 
-#[cfg(feature = "std")]
-impl TryFrom<ngx_str_t> for String {
-    type Error = std::string::FromUtf8Error;
+impl TryFrom<ngx_str_t> for string::String {
+    type Error = string::FromUtf8Error;
 
     fn try_from(s: ngx_str_t) -> Result<Self, Self::Error> {
         let bytes: &[u8] = s.into();
-        String::from_utf8(bytes.into())
+        string::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()))
+        write!(f, "{}", string::String::from_utf8_lossy((*self).into()))
     }
 }
 
@@ -234,6 +334,6 @@ pub unsafe fn add_to_ngx_table(
         table.key.data = str_to_uchar(pool, key);
         table.value.len = value.len();
         table.value.data = str_to_uchar(pool, value);
-        table.lowcase_key = str_to_uchar(pool, String::from(key).to_ascii_lowercase().as_str());
+        table.lowcase_key = str_to_uchar(pool, string::String::from(key).to_ascii_lowercase().as_str());
     })
 }

src/core/string.rs

@@ -3,6 +3,11 @@ use core::str::{self, Utf8Error};
 
 use crate::ffi::*;
 
+#[cfg(not(feature = "std"))]
+use alloc::{borrow::Cow, string::String};
+#[cfg(feature = "std")]
+use std::{borrow::Cow, string::String};
+
 /// Static string initializer for [`ngx_str_t`].
 ///
 /// The resulting byte string is always nul-terminated (just like a C string).
@@ -63,8 +68,7 @@ impl NgxStr {
     /// Converts an [`NgxStr`] into a [`Cow<str>`], replacing invalid UTF-8 sequences.
     ///
     /// See [`String::from_utf8_lossy`].
-    #[cfg(feature = "std")]
-    pub fn to_string_lossy(&self) -> std::borrow::Cow<str> {
+    pub fn to_string_lossy(&self) -> Cow<str> {
         String::from_utf8_lossy(self.as_bytes())
     }
 

src/http/request.rs

@@ -1,6 +1,7 @@
 use core::error::Error;
 use core::ffi::c_void;
 use core::fmt;
+use core::marker::PhantomData;
 use core::str::FromStr;
 
 use crate::core::*;
@@ -106,6 +107,32 @@ impl<'a> From<&'a mut Request> for *mut ngx_http_request_t {
     }
 }
 
+impl crate::log::LogTarget for ngx_http_request_t {
+    #[inline]
+    fn debug_mask(&self) -> crate::log::DebugMask {
+        crate::log::DebugMask::Http
+    }
+
+    #[inline]
+    fn get_log(&self) -> *const ngx_log_t {
+        // SAFETY: request must have a connecton and connection must have log
+        unsafe { (*self.connection).log }
+    }
+}
+
+impl crate::log::LogTarget for Request {
+    #[inline]
+    fn debug_mask(&self) -> crate::log::DebugMask {
+        crate::log::DebugMask::Http
+    }
+
+    #[inline]
+    fn get_log(&self) -> *const ngx_log_t {
+        // SAFETY: request must have a connecton and connection must have log
+        unsafe { (*self.connection()).log }
+    }
+}
+
 impl Request {
     /// Create a [`Request`] from an [`ngx_http_request_t`].
     ///
@@ -427,38 +454,38 @@ impl fmt::Debug for Request {
 /// Iterator for [`ngx_list_t`] types.
 ///
 /// Implementes the core::iter::Iterator trait.
-pub struct NgxListIterator {
+pub struct NgxListIterator<'a> {
     done: bool,
     part: *const ngx_list_part_t,
     h: *const ngx_table_elt_t,
     i: ngx_uint_t,
+    __: PhantomData<&'a ()>,
 }
 
 /// Creates new HTTP header iterator
 ///
 /// # Safety
 ///
 /// The caller has provided a valid [`ngx_str_t`] which can be dereferenced validly.
-pub unsafe fn list_iterator(list: *const ngx_list_t) -> NgxListIterator {
+pub unsafe fn list_iterator<'a>(list: &'a ngx_list_t) -> NgxListIterator<'a> {
     let part: *const ngx_list_part_t = &(*list).part;
 
     NgxListIterator {
         done: false,
         part,
         h: (*part).elts as *const ngx_table_elt_t,
         i: 0,
+        __: PhantomData,
     }
 }
 
 // iterator for ngx_list_t
-impl Iterator for NgxListIterator {
-    // type Item = (&str,&str);
-    // TODO: try to use str instead of string
+impl<'a> Iterator for NgxListIterator<'a> {
+    type Item = (&'a str, &'a str);
+    // TODO: try to use struct instead of &str pair
     // something like pub struct Header(ngx_table_elt_t);
     // then header would have key and value
 
-    type Item = (String, String);
-
     fn next(&mut self) -> Option<Self::Item> {
         unsafe {
             if self.done {
@@ -477,10 +504,10 @@ impl Iterator for NgxListIterator {
                 }
 
                 let header: *const ngx_table_elt_t = self.h.add(self.i);
-                let header_name: ngx_str_t = (*header).key;
-                let header_value: ngx_str_t = (*header).value;
+                let header_name: &ngx_str_t = &(*header).key;
+                let header_value: &ngx_str_t = &(*header).value;
                 self.i += 1;
-                Some((header_name.to_string(), header_value.to_string()))
+                Some((header_name.to_str(), header_value.to_str()))
             }
         }
     }

src/http/status.rs

@@ -25,7 +25,7 @@ impl InvalidHTTPStatusCode {
 
 impl fmt::Display for InvalidHTTPStatusCode {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str("invalid status code".to_string().as_str())
+        f.write_str("invalid status code")
     }
 }
 

src/lib.rs

@@ -32,9 +32,11 @@
 //! # now you can use dynamic modules with the NGINX
 //! ```
 
-// support both std and no_std
 #![cfg_attr(not(feature = "std"), no_std)]
 #![warn(missing_docs)]
+#[cfg(not(feature = "std"))]
+extern crate alloc;
+
 /// The core module.
 ///
 /// This module provides fundamental utilities needed to interface with many NGINX primitives.
@@ -61,8 +63,10 @@ pub mod log;
 /// The test utility module.
 ///
 /// This module provides utilities for integration tests with bundled NGINX.
-#[cfg(feature = "test_util")]
+#[cfg(all(feature = "test_util", feature = "std"))]
 pub mod test_util;
+#[cfg(all(feature = "test_util", not(feature = "std")))]
+compile_error!("feature \"test_util\" requires feature \"std\"");
 
 /// Define modules exported by this library.
 ///