feat: support unaligned allocations from the pool

Use unaligned allocations for strings.

Author: bavshin-f5

examples/httporigdst.rs

@@ -28,7 +28,7 @@ impl Default for NgxHttpOrigDstCtx {
 
 impl NgxHttpOrigDstCtx {
     pub fn save(&mut self, addr: &str, port: in_port_t, pool: &mut core::Pool) -> core::Status {
-        let addr_data = pool.alloc(addr.len());
+        let addr_data = pool.alloc_unaligned(addr.len());
         if addr_data.is_null() {
             return core::Status::NGX_ERROR;
         }
@@ -37,7 +37,7 @@ impl NgxHttpOrigDstCtx {
         self.orig_dst_addr.data = addr_data as *mut u8;
 
         let port_str = port.to_string();
-        let port_data = pool.alloc(port_str.len());
+        let port_data = pool.alloc_unaligned(port_str.len());
         if port_data.is_null() {
             return core::Status::NGX_ERROR;
         }

nginx-sys/src/lib.rs

@@ -57,7 +57,7 @@ pub use bindings::*;
 /// * `data` - The string slice to convert to a raw pointer.
 ///
 /// # Safety
-/// This function is marked as unsafe because it involves raw pointer manipulation and direct memory allocation using `ngx_palloc`.
+/// This function is marked as unsafe because it involves raw pointer manipulation and direct memory allocation using `ngx_pnalloc`.
 ///
 /// # Returns
 /// A raw pointer (`*mut u_char`) to the allocated memory containing the converted string data.
@@ -69,7 +69,7 @@ pub use bindings::*;
 /// let ptr = str_to_uchar(pool, data);
 /// ```
 pub unsafe fn str_to_uchar(pool: *mut ngx_pool_t, data: &str) -> *mut u_char {
-    let ptr: *mut u_char = ngx_palloc(pool, data.len() as _) as _;
+    let ptr: *mut u_char = ngx_pnalloc(pool, data.len()) as _;
     copy_nonoverlapping(data.as_ptr(), ptr, data.len());
     ptr
 }

src/core/pool.rs

@@ -85,33 +85,51 @@ impl Pool {
     }
 
     /// Allocates memory from the pool of the specified size.
+    /// The resulting pointer is aligned to a platform word size.
     ///
     /// Returns a raw pointer to the allocated memory.
     pub fn alloc(&mut self, size: usize) -> *mut c_void {
         unsafe { ngx_palloc(self.0, size) }
     }
 
     /// Allocates memory for a type from the pool.
+    /// The resulting pointer is aligned to a platform word size.
     ///
     /// Returns a typed pointer to the allocated memory.
     pub fn alloc_type<T: Copy>(&mut self) -> *mut T {
         self.alloc(mem::size_of::<T>()) as *mut T
     }
 
     /// Allocates zeroed memory from the pool of the specified size.
+    /// The resulting pointer is aligned to a platform word size.
     ///
     /// Returns a raw pointer to the allocated memory.
     pub fn calloc(&mut self, size: usize) -> *mut c_void {
         unsafe { ngx_pcalloc(self.0, size) }
     }
 
     /// Allocates zeroed memory for a type from the pool.
+    /// The resulting pointer is aligned to a platform word size.
     ///
     /// Returns a typed pointer to the allocated memory.
     pub fn calloc_type<T: Copy>(&mut self) -> *mut T {
         self.calloc(mem::size_of::<T>()) as *mut T
     }
 
+    /// Allocates unaligned memory from the pool of the specified size.
+    ///
+    /// Returns a raw pointer to the allocated memory.
+    pub fn alloc_unaligned(&mut self, size: usize) -> *mut c_void {
+        unsafe { ngx_pnalloc(self.0, size) }
+    }
+
+    /// Allocates unaligned memory for a type from the pool.
+    ///
+    /// Returns a typed pointer to the allocated memory.
+    pub fn alloc_type_unaligned<T: Copy>(&mut self) -> *mut T {
+        self.alloc_unaligned(mem::size_of::<T>()) as *mut T
+    }
+
     /// Allocates memory for a value of a specified type and adds a cleanup handler to the memory pool.
     ///
     /// Returns a typed pointer to the allocated memory if successful, or a null pointer if allocation or cleanup handler addition fails.