fix: refactor NgxListIterator to remove String usage

Author: JyJyJcr

src/http/request.rs

@@ -1,5 +1,6 @@
 use core::ffi::c_void;
 use core::fmt;
+use core::slice::from_raw_parts;
 use core::str::FromStr;
 
 use crate::core::*;
@@ -394,13 +395,13 @@ impl Request {
     }
 
     /// Iterate over headers_in
-    /// each header item is (String, String) (copied)
+    /// each header item is (&str, &str) (borrowed)
     pub fn headers_in_iterator(&self) -> NgxListIterator {
         unsafe { list_iterator(&self.0.headers_in.headers) }
     }
 
     /// Iterate over headers_out
-    /// each header item is (String, String) (copied)
+    /// each header item is (&str, &str) (borrowed)
     pub fn headers_out_iterator(&self) -> NgxListIterator {
         unsafe { list_iterator(&self.0.headers_out.headers) }
     }
@@ -424,62 +425,60 @@ impl fmt::Debug for Request {
 /// Iterator for [`ngx_list_t`] types.
 ///
 /// Implementes the core::iter::Iterator trait.
-pub struct NgxListIterator {
-    done: bool,
-    part: *const ngx_list_part_t,
-    h: *const ngx_table_elt_t,
+pub struct NgxListIterator<'a> {
+    part: Option<ListPart<'a>>,
     i: ngx_uint_t,
 }
+struct ListPart<'a> {
+    raw: &'a ngx_list_part_t,
+    arr: &'a [ngx_table_elt_t],
+}
+impl<'a> From<&'a ngx_list_part_t> for ListPart<'a> {
+    fn from(raw: &'a ngx_list_part_t) -> Self {
+        let arr = if let Some(elts) = unsafe { raw.elts.cast::<ngx_table_elt_t>().as_ref() } {
+            unsafe { from_raw_parts(elts, raw.nelts) }
+        } else {
+            &[]
+        };
+        Self { raw, arr }
+    }
+}
 
 /// 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 {
-    let part: *const ngx_list_part_t = &(*list).part;
-
+pub unsafe fn list_iterator(list: &ngx_list_t) -> NgxListIterator {
     NgxListIterator {
-        done: false,
-        part,
-        h: (*part).elts as *const ngx_table_elt_t,
+        part: Some((&list.part).into()),
         i: 0,
     }
 }
 
 // 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> {
+    // 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);
+    type Item = (&'a str, &'a str);
 
     fn next(&mut self) -> Option<Self::Item> {
-        unsafe {
-            if self.done {
-                None
+        let part = self.part.as_mut()?;
+        if self.i >= part.arr.len() {
+            if let Some(next_part_raw) = unsafe { part.raw.next.as_ref() } {
+                // loop back
+                *part = next_part_raw.into();
+                self.i = 0;
             } else {
-                if self.i >= (*self.part).nelts {
-                    if (*self.part).next.is_null() {
-                        self.done = true;
-                        return None;
-                    }
-
-                    // loop back
-                    self.part = (*self.part).next;
-                    self.h = (*self.part).elts as *mut ngx_table_elt_t;
-                    self.i = 0;
-                }
-
-                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;
-                self.i += 1;
-                Some((header_name.to_string(), header_value.to_string()))
+                self.part = None;
+                return None;
             }
         }
+        let header = &part.arr[self.i];
+        self.i += 1;
+        Some((header.key.to_str(), header.value.to_str()))
     }
 }