From ec5de067f11a5e40794890fd3e4f9944ec2f9771 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Fri, 1 May 2026 02:27:17 +0200
Subject: [PATCH 01/24] wip

---
 libuci-sys/src/lib.rs          |  10 +++
 rust-uci/src/config/mod.rs     | 119 +++++++++++++++++++++++++++++++++
 rust-uci/src/config/option.rs  |  45 +++++++++++++
 rust-uci/src/config/package.rs |  97 +++++++++++++++++++++++++++
 rust-uci/src/config/section.rs |  76 +++++++++++++++++++++
 rust-uci/src/lib.rs            |  78 +++++++++++----------
 6 files changed, 389 insertions(+), 36 deletions(-)
 create mode 100644 rust-uci/src/config/mod.rs
 create mode 100644 rust-uci/src/config/option.rs
 create mode 100644 rust-uci/src/config/package.rs
 create mode 100644 rust-uci/src/config/section.rs

diff --git a/libuci-sys/src/lib.rs b/libuci-sys/src/lib.rs
index 0ab82cd..f40e19e 100644
--- a/libuci-sys/src/lib.rs
+++ b/libuci-sys/src/lib.rs
@@ -105,6 +105,16 @@ pub unsafe fn list_to_element(ptr: *const uci_list) -> *const uci_element {
     container_of!(ptr, uci_element, list)
 }
 
+/// casts an [`uci_element`] pointer to the containing [`uci_package`].
+///
+/// # Safety
+/// The caller must ensure that `ptr` points to an element which is member of an [`uci_package`].
+/// The `ptr` must not point to an element which is not contained in an uci_package.
+pub unsafe fn uci_to_package(ptr: *const uci_element) -> *const uci_package {
+    // safety: uci_package.e has type uci_element, ptr points to uci_element
+    container_of!(ptr, uci_package, e)
+}
+
 /// casts an [`uci_element`] pointer to the containing [`uci_section`].
 ///
 /// # Safety
diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
new file mode 100644
index 0000000..fac243c
--- /dev/null
+++ b/rust-uci/src/config/mod.rs
@@ -0,0 +1,119 @@
+use std::{ffi::CString, marker::PhantomData, option::Option as StdOption, ptr};
+
+use libuci_sys::{list_to_element, uci_element, uci_list, uci_lookup_next, uci_to_package};
+
+use crate::{
+    error::{Error, Result},
+    libuci_locked, Uci, UCI_ERR_NOTFOUND, UCI_OK,
+};
+
+mod option;
+
+mod package;
+use package::{Package, PackageRef};
+
+mod section;
+
+#[derive(Clone)]
+pub(crate) enum NameOrRef<N, T> {
+    Name(N),
+    Ref(T),
+}
+
+unsafe trait FromUciElement {
+    unsafe fn from_uci_element(elem: *const uci_element) -> Self;
+}
+
+struct UciListIter<Item> {
+    list: *const uci_list,
+    _out: PhantomData<Item>,
+}
+
+impl<Item> UciListIter<Item> {
+    fn new(list: *const uci_list) -> Self {
+        Self {
+            list,
+            _out: PhantomData,
+        }
+    }
+}
+
+impl<Item> Iterator for UciListIter<Item>
+where
+    Item: FromUciElement,
+{
+    type Item = Item;
+
+    fn next(&mut self) -> StdOption<Self::Item> {
+        if self.list.is_null() {
+            return None;
+        }
+
+        let node = unsafe { (*self.list).next };
+        if node.is_null() {
+            return None;
+        }
+        if node.cast_const() == self.list {
+            return None;
+        }
+
+        let elem = unsafe { list_to_element(node.cast_const()) };
+        Some(unsafe { Item::from_uci_element(elem) })
+    }
+}
+
+/// represents the root of the config tree
+/// It's the parent structure to [Package]s
+pub struct Config {
+    uci: Uci,
+}
+
+impl Config {
+    pub fn new() -> Result<Self> {
+        Ok(Self { uci: Uci::new()? })
+    }
+
+    /// return a single [Package] by its name
+    /// also works if the package is not defined yet
+    pub fn package<'a>(&'a mut self, name: impl AsRef<str>) -> Result<Package<'a>> {
+        let root = &mut (unsafe { *self.uci.ctx }).root;
+        let pkg = lookup_child(&mut self.uci, root, &name)?
+            .map(|e| NameOrRef::Ref(unsafe { uci_to_package(e) }.into()))
+            .unwrap_or_else(|| NameOrRef::Name(name.as_ref().to_owned()));
+        Ok(Package::new(&mut self.uci, pkg))
+    }
+
+    /// list all [Package]s in the config
+    pub fn packages(&mut self) -> impl Iterator<Item = PackageRef> {
+        // Safety:
+        // - self.uci.ctx is not null
+        let packages = unsafe { (&(*self.uci.ctx).root) as *const _ };
+        UciListIter::new(packages)
+    }
+}
+
+fn lookup_child(
+    uci: &mut Uci,
+    parent: *mut uci_list,
+    name: impl AsRef<str>,
+) -> Result<StdOption<*mut uci_element>> {
+    let raw = CString::new(name.as_ref())?;
+    let mut elem = ptr::null_mut();
+    let result = libuci_locked!(uci, {
+        unsafe { uci_lookup_next(uci.ctx, &mut elem as *mut _, parent, raw.as_ptr()) }
+    });
+    match result {
+        UCI_OK => (),
+        UCI_ERR_NOTFOUND => {
+            return Ok(None);
+        }
+        _ => {
+            return Err(Error::Message(
+                uci.get_last_error()
+                    .unwrap_or_else(|_| String::from("Unknown")),
+            ));
+        }
+    }
+
+    Ok(Some(elem))
+}
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
new file mode 100644
index 0000000..8186f1f
--- /dev/null
+++ b/rust-uci/src/config/option.rs
@@ -0,0 +1,45 @@
+use std::option::Option as StdOption;
+
+use crate::{Result, UciPtr};
+
+/// represents the value of an [Option]
+pub enum Value {
+    String(String),
+    Boolean(bool),
+    Integer(i64),
+    List(Vec<Value>),
+}
+
+/// represents an option within a [Section]
+pub struct Option {
+    _ptr: UciPtr,
+}
+
+impl Option {
+    /// name of the option
+    pub fn name(&mut self) -> Result<String> {
+        todo!()
+    }
+
+    /// returns the current value of the option, None if not set
+    pub fn get(&mut self) -> Result<StdOption<Value>> {
+        todo!()
+    }
+
+    /// sets the value of the option, overriding the previous value
+    /// will create the [Package] or [Section] along the way if they do
+    /// not exist
+    pub fn set(&mut self, _value: Value) -> Result<()> {
+        todo!()
+    }
+
+    /// adds a value to the existing value
+    /// behaves like `uci add_list` which will:
+    /// - create the option if it doesn't exist (not as a list)
+    /// - turn a single-value option into a list
+    ///
+    /// returns the resulting value
+    pub fn add_list(&mut self, _value: Value) -> Result<Value> {
+        todo!()
+    }
+}
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
new file mode 100644
index 0000000..7102fba
--- /dev/null
+++ b/rust-uci/src/config/package.rs
@@ -0,0 +1,97 @@
+use std::ffi::CStr;
+
+use libuci_sys::{uci_element, uci_package, uci_to_package, uci_to_section};
+
+use crate::{config::lookup_child, Result, Uci};
+
+use super::{section::Section, FromUciElement, NameOrRef};
+
+#[derive(Clone)]
+pub struct PackageRef {
+    pkg: *const uci_package,
+}
+
+impl From<*const uci_package> for PackageRef {
+    fn from(pkg: *const uci_package) -> Self {
+        Self { pkg }
+    }
+}
+
+impl PackageRef {
+    pub fn get<'a>(self, uci: &'a mut Uci) -> Package<'a> {
+        Package {
+            uci,
+            pkg: NameOrRef::Ref(self),
+        }
+    }
+
+    pub fn name(&self) -> Result<&str> {
+        unsafe { CStr::from_ptr((*self.pkg).path) }
+            .to_str()
+            .map_err(Into::into)
+    }
+}
+
+/// represents a single package in the config tree
+/// parent to different [Section]s
+pub struct Package<'a> {
+    uci: &'a mut Uci,
+    pkg: NameOrRef<String, PackageRef>,
+}
+
+impl<'a> Package<'a> {
+    pub(crate) fn new(uci: &'a mut Uci, pkg: NameOrRef<String, PackageRef>) -> Self {
+        Self { uci, pkg }
+    }
+
+    /// name of this package
+    pub fn name(&self) -> Result<&str> {
+        match &self.pkg {
+            NameOrRef::Name(name) => Ok(name),
+            NameOrRef::Ref(pkg) => pkg.name(),
+        }
+    }
+
+    /// return a single [Section] by its name
+    /// also works if the section is not defined yet
+    pub fn section(
+        &'a mut self,
+        name: impl AsRef<str>,
+        section_type: impl AsRef<str>,
+    ) -> Result<Section<'a>> {
+        let name = name.as_ref();
+        let section_type = section_type.as_ref();
+
+        let pkg = match &self.pkg {
+            NameOrRef::Name(_) => {
+                return Ok(Section::new(
+                    self.uci,
+                    self.pkg.clone(),
+                    NameOrRef::Name((name.to_owned(), section_type.to_owned())),
+                ))
+            }
+            NameOrRef::Ref(pkg) => pkg,
+        };
+
+        let section = lookup_child(self.uci, &mut unsafe { *pkg.pkg }.sections, name)?
+            .map(|ptr| NameOrRef::Ref(unsafe { uci_to_section(ptr) }.into()))
+            .unwrap_or_else(|| NameOrRef::Name((name.to_owned(), section_type.to_owned())));
+        Ok(Section::new(self.uci, self.pkg.clone(), section))
+    }
+
+    /// list all [Section]s in this package
+    pub fn sections(&'a mut self) -> Result<impl Iterator<Item = Section<'a>>> {
+        Ok(vec![].into_iter())
+    }
+}
+
+unsafe impl FromUciElement for PackageRef {
+    /// # Safety
+    /// - Caller must guarantee that elem contains a `uci_package`
+    /// - Caller must guarantee that elem is not null
+    unsafe fn from_uci_element(elem: *const uci_element) -> Self {
+        Self {
+            pkg: uci_to_package(elem),
+        }
+    }
+}
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
new file mode 100644
index 0000000..c2c4a15
--- /dev/null
+++ b/rust-uci/src/config/section.rs
@@ -0,0 +1,76 @@
+use std::ffi::CStr;
+
+use libuci_sys::uci_section;
+
+use crate::{
+    config::{package::PackageRef, NameOrRef},
+    Result, Uci,
+};
+
+use super::option::Option;
+
+pub struct SectionRef {
+    section: *const uci_section,
+}
+
+impl SectionRef {
+    pub fn name(&self) -> Result<&str> {
+        let ptr = unsafe { *self.section }.e.name;
+        Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?)
+    }
+}
+
+impl From<*const uci_section> for SectionRef {
+    fn from(section: *const uci_section) -> Self {
+        Self { section }
+    }
+}
+
+/// represents a single section
+/// parent to different [Option]s
+pub struct Section<'a> {
+    uci: &'a mut Uci,
+    parent: NameOrRef<String, PackageRef>,
+    section: NameOrRef<(String, String), SectionRef>,
+}
+
+impl<'a> Section<'a> {
+    pub(crate) fn new(
+        uci: &'a mut Uci,
+        parent: NameOrRef<String, PackageRef>,
+        section: NameOrRef<(String, String), SectionRef>,
+    ) -> Self {
+        Self {
+            uci,
+            parent,
+            section,
+        }
+    }
+
+    /// returns the name of named sections, otherwise None
+    pub fn name(&mut self) -> Result<&str> {
+        match &self.section {
+            NameOrRef::Name((name, _)) => Ok(name),
+            NameOrRef::Ref(_) => todo!(),
+        }
+    }
+
+    /// returns the type of the section
+    pub fn r#type(&mut self) -> Result<&str> {
+        match &self.section {
+            NameOrRef::Name((_, stype)) => Ok(stype),
+            NameOrRef::Ref(_) => todo!(),
+        }
+    }
+
+    /// returns a specific [Option] by name
+    /// also works if the option is not defined yet
+    pub fn option(&mut self, _name: impl AsRef<str>) -> Result<Option> {
+        todo!()
+    }
+
+    /// lists all options in this section
+    pub fn options(&mut self) -> Result<impl Iterator<Item = Option>> {
+        Ok(vec![].into_iter())
+    }
+}
diff --git a/rust-uci/src/lib.rs b/rust-uci/src/lib.rs
index b5a0f1f..c693441 100644
--- a/rust-uci/src/lib.rs
+++ b/rust-uci/src/lib.rs
@@ -50,6 +50,7 @@
 //!
 //! ```
 
+pub mod config;
 pub mod error;
 
 use core::ptr;
@@ -62,7 +63,6 @@ use libuci_sys::{
 };
 use log::debug;
 use std::ffi::{c_char, c_int};
-use std::sync::Mutex;
 use std::{
     ffi::{CStr, CString},
     ops::{Deref, DerefMut},
@@ -73,44 +73,50 @@ use crate::error::{Error, Result};
 const UCI_OK: c_int = libuci_sys::UCI_OK as c_int;
 const UCI_ERR_NOTFOUND: c_int = libuci_sys::UCI_ERR_NOTFOUND as c_int;
 
-// Global lock to ensure that only one instance of libuci function calls is running at the time.
-// Necessary because libuci uses thread-unsafe functions with global state (e.g., strtok).
-static LIBRARY_LOCK: Mutex<()> = Mutex::new(());
-
-// Ensures that the global library lock is held while evaluating `$call`.
-// The second parameter indicates whether a check for reentrancy should be performed, and requires
-// `self` to be a mutable borrow of a `Uci` instance.
-macro_rules! libuci_locked {
-    ($self:ident, $call:expr) => {{
-        // Lock global library mutex, if we aren't already holding it in a function call higher up
-        // in the stack.
-        let libuci_lock_guard = if !$self.lock_held {
-            let libuci_lock_guard = Some(
-                LIBRARY_LOCK
+#[macro_use]
+mod macros {
+    use std::sync::Mutex;
+
+    // Global lock to ensure that only one instance of libuci function calls is running at the time.
+    // Necessary because libuci uses thread-unsafe functions with global state (e.g., strtok).
+    pub static LIBRARY_LOCK: Mutex<()> = Mutex::new(());
+
+    // Ensures that the global library lock is held while evaluating `$call`.
+    // The second parameter indicates whether a check for reentrancy should be performed, and requires
+    // `self` to be a mutable borrow of a `Uci` instance.
+    #[macro_export]
+    macro_rules! libuci_locked {
+        ($self:ident, $call:expr) => {{
+            // Lock global library mutex, if we aren't already holding it in a function call higher up
+            // in the stack.
+            let libuci_lock_guard = if !$self.lock_held {
+                let libuci_lock_guard = Some(
+                    $crate::macros::LIBRARY_LOCK
+                        .lock()
+                        .expect("global libuci library lock was poisoned."),
+                );
+                $self.lock_held = true;
+                libuci_lock_guard
+            } else {
+                None
+            };
+            let result = $call;
+            // If we were the ones who locked the global library lock, release it.
+            if let Some(libuci_lock_guard) = libuci_lock_guard {
+                $self.lock_held = false;
+                drop(libuci_lock_guard);
+            }
+            result
+        }};
+        ($call:expr) => {{
+            let _libuci_lock_guard = Some(
+                $crate::macros::LIBRARY_LOCK
                     .lock()
                     .expect("global libuci library lock was poisoned."),
             );
-            $self.lock_held = true;
-            libuci_lock_guard
-        } else {
-            None
-        };
-        let result = $call;
-        // If we were the ones who locked the global library lock, release it.
-        if let Some(libuci_lock_guard) = libuci_lock_guard {
-            $self.lock_held = false;
-            drop(libuci_lock_guard);
-        }
-        result
-    }};
-    ($call:expr) => {{
-        let _libuci_lock_guard = Some(
-            LIBRARY_LOCK
-                .lock()
-                .expect("global libuci library lock was poisoned."),
-        );
-        $call
-    }};
+            $call
+        }};
+    }
 }
 
 /// Contains the native `uci_context`

From 5b32ce8bce655c78fb62efb3226b2b8c5f7a3a7a Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Fri, 1 May 2026 15:49:19 +0200
Subject: [PATCH 02/24] Half-working impl

---
 libuci-sys/src/lib.rs          |  18 ++++-
 rust-uci/src/config/mod.rs     | 123 ++++++++++++++++++++++-------
 rust-uci/src/config/option.rs  | 139 +++++++++++++++++++++++++++++----
 rust-uci/src/config/package.rs |  57 +++++++-------
 rust-uci/src/config/section.rs |  83 ++++++++++++++------
 5 files changed, 319 insertions(+), 101 deletions(-)

diff --git a/libuci-sys/src/lib.rs b/libuci-sys/src/lib.rs
index f40e19e..371d122 100644
--- a/libuci-sys/src/lib.rs
+++ b/libuci-sys/src/lib.rs
@@ -31,10 +31,10 @@ pub use bindings::{
     uci_commit, uci_context, uci_del_list, uci_delete, uci_delta, uci_element, uci_export,
     uci_flags, uci_free_context, uci_get_errorstr, uci_hash_options, uci_import, uci_list,
     uci_list_configs, uci_load, uci_lookup_next, uci_lookup_ptr, uci_option, uci_option_type,
-    uci_option_type_UCI_TYPE_STRING, uci_package, uci_parse_argument, uci_parse_context,
-    uci_parse_option, uci_parse_ptr, uci_parse_section, uci_perror, uci_ptr,
-    uci_ptr_UCI_LOOKUP_COMPLETE, uci_rename, uci_reorder_section, uci_revert, uci_save,
-    uci_section, uci_set, uci_set_backend, uci_set_confdir, uci_set_savedir, uci_type,
+    uci_option_type_UCI_TYPE_LIST, uci_option_type_UCI_TYPE_STRING, uci_package,
+    uci_parse_argument, uci_parse_context, uci_parse_option, uci_parse_ptr, uci_parse_section,
+    uci_perror, uci_ptr, uci_ptr_UCI_LOOKUP_COMPLETE, uci_rename, uci_reorder_section, uci_revert,
+    uci_save, uci_section, uci_set, uci_set_backend, uci_set_confdir, uci_set_savedir, uci_type,
     uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_SECTION, uci_unload, uci_validate_text,
     UCI_ERR_NOTFOUND, UCI_OK,
 };
@@ -125,6 +125,16 @@ pub unsafe fn uci_to_section(ptr: *const uci_element) -> *const uci_section {
     container_of!(ptr, uci_section, e)
 }
 
+/// casts an [`uci_element`] pointer to the containing [`uci_option`].
+///
+/// # Safety
+/// The caller must ensure that `ptr` points to an element which is member of an [`uci_option`].
+/// The `ptr` must not point to an element which is not contained in an uci_element.
+pub unsafe fn uci_to_option(ptr: *const uci_element) -> *const uci_option {
+    // safety: uci_option.e has type uci_element, ptr points to uci_element
+    container_of!(ptr, uci_option, e)
+}
+
 /// mimics the C-macro `uci_foreach_element`
 ///
 /// Note: the list head is not considered as a data node, and is skipped during iteration.
diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index fac243c..67a675d 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -1,6 +1,8 @@
-use std::{ffi::CString, marker::PhantomData, option::Option as StdOption, ptr};
+use std::{ffi::CString, option::Option as StdOption, ptr};
 
-use libuci_sys::{list_to_element, uci_element, uci_list, uci_lookup_next, uci_to_package};
+use libuci_sys::{
+    list_to_element, uci_element, uci_list, uci_load, uci_lookup_next, uci_to_package,
+};
 
 use crate::{
     error::{Error, Result},
@@ -20,29 +22,18 @@ pub(crate) enum NameOrRef<N, T> {
     Ref(T),
 }
 
-unsafe trait FromUciElement {
-    unsafe fn from_uci_element(elem: *const uci_element) -> Self;
-}
-
-struct UciListIter<Item> {
+struct UciListIter {
     list: *const uci_list,
-    _out: PhantomData<Item>,
 }
 
-impl<Item> UciListIter<Item> {
+impl UciListIter {
     fn new(list: *const uci_list) -> Self {
-        Self {
-            list,
-            _out: PhantomData,
-        }
+        Self { list }
     }
 }
 
-impl<Item> Iterator for UciListIter<Item>
-where
-    Item: FromUciElement,
-{
-    type Item = Item;
+impl Iterator for UciListIter {
+    type Item = *const uci_element;
 
     fn next(&mut self) -> StdOption<Self::Item> {
         if self.list.is_null() {
@@ -57,8 +48,7 @@ where
             return None;
         }
 
-        let elem = unsafe { list_to_element(node.cast_const()) };
-        Some(unsafe { Item::from_uci_element(elem) })
+        Some(unsafe { list_to_element(node.cast_const()) })
     }
 }
 
@@ -68,6 +58,12 @@ pub struct Config {
     uci: Uci,
 }
 
+impl From<Uci> for Config {
+    fn from(uci: Uci) -> Self {
+        Self { uci }
+    }
+}
+
 impl Config {
     pub fn new() -> Result<Self> {
         Ok(Self { uci: Uci::new()? })
@@ -76,19 +72,32 @@ impl Config {
     /// return a single [Package] by its name
     /// also works if the package is not defined yet
     pub fn package<'a>(&'a mut self, name: impl AsRef<str>) -> Result<Package<'a>> {
-        let root = &mut (unsafe { *self.uci.ctx }).root;
-        let pkg = lookup_child(&mut self.uci, root, &name)?
-            .map(|e| NameOrRef::Ref(unsafe { uci_to_package(e) }.into()))
+        let root = (unsafe { *self.uci.ctx }).root;
+        let lookup = lookup_child(&mut self.uci, root.next, &name)?;
+        let lookup = match lookup {
+            None => {
+                let mut pkg = ptr::null_mut();
+                let raw_name = CString::new(name.as_ref())?;
+                let result = unsafe { uci_load(self.uci.ctx, raw_name.as_ptr(), &mut pkg) };
+                handle_error(&mut self.uci, result)?.map(|_| pkg.cast_const())
+            }
+            Some(v) => Some(unsafe { uci_to_package(v) }),
+        };
+        let pkg = lookup
+            .map(|e| NameOrRef::Ref(unsafe { PackageRef::new(e) }))
             .unwrap_or_else(|| NameOrRef::Name(name.as_ref().to_owned()));
         Ok(Package::new(&mut self.uci, pkg))
     }
 
     /// list all [Package]s in the config
-    pub fn packages(&mut self) -> impl Iterator<Item = PackageRef> {
-        // Safety:
-        // - self.uci.ctx is not null
+    pub fn packages<'a>(&'a mut self) -> impl Iterator<Item = PackageRef<'a>> {
+        // todo: this is broken, since packages are loaded on demand
+        // needs to use `uci_list_configs`
+
+        // Safety: self.uci.ctx is not null
         let packages = unsafe { (&(*self.uci.ctx).root) as *const _ };
-        UciListIter::new(packages)
+        // Safety: elem is not null
+        UciListIter::new(packages).map(|elem| unsafe { PackageRef::new(uci_to_package(elem)) })
     }
 }
 
@@ -102,8 +111,12 @@ fn lookup_child(
     let result = libuci_locked!(uci, {
         unsafe { uci_lookup_next(uci.ctx, &mut elem as *mut _, parent, raw.as_ptr()) }
     });
+    Ok(handle_error(uci, result)?.map(|_| elem))
+}
+
+fn handle_error(uci: &mut Uci, result: i32) -> Result<Option<()>> {
     match result {
-        UCI_OK => (),
+        UCI_OK => Ok(Some(())),
         UCI_ERR_NOTFOUND => {
             return Ok(None);
         }
@@ -114,6 +127,58 @@ fn lookup_child(
             ));
         }
     }
+}
 
-    Ok(Some(elem))
+#[cfg(test)]
+mod tests {
+    use tempfile::{tempdir, TempDir};
+
+    use super::*;
+
+    fn setup_uci() -> Result<(Uci, TempDir)> {
+        let mut uci = Uci::new()?;
+        let tmp = tempdir().unwrap();
+        let config_dir = tmp.path().join("config");
+        let save_dir = tmp.path().join("save");
+
+        std::fs::create_dir_all(&config_dir).unwrap();
+        std::fs::create_dir_all(&save_dir).unwrap();
+
+        uci.set_config_dir(config_dir.as_os_str().to_str().unwrap())?;
+        uci.set_save_dir(save_dir.as_os_str().to_str().unwrap())?;
+        Ok((uci, tmp))
+    }
+
+    #[test]
+    fn get_option() {
+        let (uci, tmp) = setup_uci().unwrap();
+        let wireless_config_path = tmp.path().join("config/wireless");
+        std::fs::write(
+            &wireless_config_path,
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+
+            config wifi-iface 'wifi0'
+                    option device 'pdev0'
+            ",
+        )
+        .unwrap();
+
+        let mut cfg: Config = uci.into();
+        let mut pkg = cfg.package("wireless").unwrap();
+        let mut sect = pkg.section("wifi-device", "pdev0").unwrap();
+        let mut opt = sect.option("channel").unwrap();
+        let val = opt.get().unwrap();
+        assert_eq!(Some(option::Value::String("auto".into())), val);
+    }
+
+    // #[test]
+    fn list_packages() {
+        let mut cfg = Config::new().unwrap();
+        let pkgs = cfg.packages();
+        for pkg in pkgs {
+            println!("{}", pkg.name().unwrap());
+        }
+    }
 }
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 8186f1f..dbf4474 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,35 +1,88 @@
-use std::option::Option as StdOption;
+use std::{
+    borrow::Cow, collections::btree_map::Values, ffi::CStr, marker::PhantomData,
+    option::Option as StdOption,
+};
 
-use crate::{Result, UciPtr};
+use libuci_sys::{
+    uci_foreach_element, uci_option, uci_option_type_UCI_TYPE_LIST, uci_option_type_UCI_TYPE_STRING,
+};
 
-/// represents the value of an [Option]
-pub enum Value {
-    String(String),
-    Boolean(bool),
-    Integer(i64),
-    List(Vec<Value>),
+use crate::{config::NameOrRef, error::Error, Result, Uci};
+
+pub struct OptionRef<'a> {
+    option: *const uci_option,
+    _lt: &'a PhantomData<()>,
+}
+
+impl<'a> OptionRef<'a> {
+    pub(crate) unsafe fn new(option: *const uci_option) -> Self {
+        Self {
+            option,
+            _lt: &PhantomData,
+        }
+    }
+
+    pub fn name(&self) -> Result<&str> {
+        let raw = unsafe { CStr::from_ptr((*self.option).e.name) };
+        Ok(raw.to_str()?)
+    }
 }
 
 /// represents an option within a [Section]
-pub struct Option {
-    _ptr: UciPtr,
+pub struct Option<'a> {
+    uci: &'a mut Uci,
+    option: NameOrRef<String, OptionRef<'a>>,
 }
 
-impl Option {
+impl<'a> Option<'a> {
+    pub(crate) fn new(uci: &'a mut Uci, option: NameOrRef<String, OptionRef<'a>>) -> Self {
+        Self { uci, option }
+    }
+
     /// name of the option
-    pub fn name(&mut self) -> Result<String> {
-        todo!()
+    pub fn name(&mut self) -> Result<&str> {
+        match &self.option {
+            NameOrRef::Name(name) => Ok(name),
+            NameOrRef::Ref(opt) => opt.name(),
+        }
     }
 
     /// returns the current value of the option, None if not set
-    pub fn get(&mut self) -> Result<StdOption<Value>> {
-        todo!()
+    pub fn get(&'a mut self) -> Result<StdOption<Value<'a>>> {
+        let opt = match &self.option {
+            NameOrRef::Name(_) => return Ok(None),
+            NameOrRef::Ref(opt) => opt.option,
+        };
+
+        #[allow(non_upper_case_globals)]
+        match unsafe { *opt }.type_ {
+            uci_option_type_UCI_TYPE_STRING => {
+                let raw = unsafe { CStr::from_ptr((*opt).v.string) };
+                Ok(Some(Value::String(raw.to_str()?.into())))
+            }
+            uci_option_type_UCI_TYPE_LIST => {
+                let mut result = Vec::new();
+                unsafe {
+                    uci_foreach_element(&(*opt).v.list, |elem| {
+                        let raw = CStr::from_ptr((*elem).name);
+                        result.push(raw);
+                    })
+                };
+                Ok(Some(Value::List(
+                    result
+                        .into_iter()
+                        .map(|cstr| cstr.to_str().map_err(Into::into).map(Into::into))
+                        .collect::<Result<Vec<_>>>()?,
+                )))
+            }
+            t => return Err(Error::Message(format!("Unexpected option type: {t}"))),
+        }
     }
 
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
-    pub fn set(&mut self, _value: Value) -> Result<()> {
+    pub fn set(&mut self, _value: Value<'static>) -> Result<()> {
         todo!()
     }
 
@@ -39,7 +92,59 @@ impl Option {
     /// - turn a single-value option into a list
     ///
     /// returns the resulting value
-    pub fn add_list(&mut self, _value: Value) -> Result<Value> {
+    pub fn add_list(&'a mut self, _value: Value) -> Result<Value<'a>> {
         todo!()
     }
 }
+
+/// represents the value of an [Option]
+#[derive(Debug)]
+pub enum Value<'a> {
+    String(Cow<'a, str>),
+    Boolean(bool),
+    Integer(i64),
+    List(Vec<Cow<'a, str>>),
+}
+
+impl<'a> Value<'a> {
+    pub fn to_static(self) -> Value<'static> {
+        match self {
+            Value::String(cow) => Value::String(cow.into_owned().into()),
+            Value::Boolean(v) => Value::Boolean(v),
+            Value::Integer(v) => Value::Integer(v),
+            Value::List(values) => {
+                Value::List(values.into_iter().map(|v| v.into_owned().into()).collect())
+            }
+        }
+    }
+}
+
+impl From<String> for Value<'static> {
+    fn from(value: String) -> Self {
+        Self::String(value.into())
+    }
+}
+
+impl From<bool> for Value<'static> {
+    fn from(value: bool) -> Self {
+        Self::Boolean(value)
+    }
+}
+
+impl From<i64> for Value<'static> {
+    fn from(value: i64) -> Self {
+        Self::Integer(value)
+    }
+}
+
+impl<'a> PartialEq for Value<'a> {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::String(l0), Self::String(r0)) => l0 == r0,
+            (Self::Boolean(l0), Self::Boolean(r0)) => l0 == r0,
+            (Self::Integer(l0), Self::Integer(r0)) => l0 == r0,
+            (Self::List(l0), Self::List(r0)) => l0 == r0,
+            _ => false,
+        }
+    }
+}
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 7102fba..daf950b 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -1,24 +1,31 @@
-use std::ffi::CStr;
+use std::{ffi::CStr, marker::PhantomData, ptr};
 
-use libuci_sys::{uci_element, uci_package, uci_to_package, uci_to_section};
+use libuci_sys::{uci_package, uci_to_section};
 
-use crate::{config::lookup_child, Result, Uci};
+use crate::{Result, Uci};
 
-use super::{section::Section, FromUciElement, NameOrRef};
+use super::{
+    lookup_child,
+    section::{Section, SectionRef},
+    NameOrRef, UciListIter,
+};
 
 #[derive(Clone)]
-pub struct PackageRef {
+pub struct PackageRef<'a> {
     pkg: *const uci_package,
+    /// lifetime of UCI context where we got pkg from
+    _lt: &'a PhantomData<()>,
 }
 
-impl From<*const uci_package> for PackageRef {
-    fn from(pkg: *const uci_package) -> Self {
-        Self { pkg }
+impl<'a> PackageRef<'a> {
+    pub(crate) unsafe fn new(pkg: *const uci_package) -> Self {
+        Self {
+            pkg,
+            _lt: &PhantomData,
+        }
     }
-}
 
-impl PackageRef {
-    pub fn get<'a>(self, uci: &'a mut Uci) -> Package<'a> {
+    pub fn get(self, uci: &'a mut Uci) -> Package<'a> {
         Package {
             uci,
             pkg: NameOrRef::Ref(self),
@@ -36,11 +43,11 @@ impl PackageRef {
 /// parent to different [Section]s
 pub struct Package<'a> {
     uci: &'a mut Uci,
-    pkg: NameOrRef<String, PackageRef>,
+    pkg: NameOrRef<String, PackageRef<'a>>,
 }
 
 impl<'a> Package<'a> {
-    pub(crate) fn new(uci: &'a mut Uci, pkg: NameOrRef<String, PackageRef>) -> Self {
+    pub(crate) fn new(uci: &'a mut Uci, pkg: NameOrRef<String, PackageRef<'a>>) -> Self {
         Self { uci, pkg }
     }
 
@@ -56,8 +63,8 @@ impl<'a> Package<'a> {
     /// also works if the section is not defined yet
     pub fn section(
         &'a mut self,
-        name: impl AsRef<str>,
         section_type: impl AsRef<str>,
+        name: impl AsRef<str>,
     ) -> Result<Section<'a>> {
         let name = name.as_ref();
         let section_type = section_type.as_ref();
@@ -74,24 +81,18 @@ impl<'a> Package<'a> {
         };
 
         let section = lookup_child(self.uci, &mut unsafe { *pkg.pkg }.sections, name)?
-            .map(|ptr| NameOrRef::Ref(unsafe { uci_to_section(ptr) }.into()))
+            .map(|ptr| NameOrRef::Ref(unsafe { SectionRef::new(pkg.pkg, uci_to_section(ptr)) }))
             .unwrap_or_else(|| NameOrRef::Name((name.to_owned(), section_type.to_owned())));
         Ok(Section::new(self.uci, self.pkg.clone(), section))
     }
 
     /// list all [Section]s in this package
-    pub fn sections(&'a mut self) -> Result<impl Iterator<Item = Section<'a>>> {
-        Ok(vec![].into_iter())
-    }
-}
-
-unsafe impl FromUciElement for PackageRef {
-    /// # Safety
-    /// - Caller must guarantee that elem contains a `uci_package`
-    /// - Caller must guarantee that elem is not null
-    unsafe fn from_uci_element(elem: *const uci_element) -> Self {
-        Self {
-            pkg: uci_to_package(elem),
-        }
+    pub fn sections(&'a mut self) -> impl Iterator<Item = SectionRef<'a>> {
+        let (pkg, list) = match &self.pkg {
+            NameOrRef::Name(_) => (ptr::null(), ptr::null()),
+            NameOrRef::Ref(pkg) => (pkg.pkg, &unsafe { *pkg.pkg }.sections as *const _),
+        };
+        UciListIter::new(list)
+            .map(move |elem| unsafe { SectionRef::new(pkg, uci_to_section(elem)) })
     }
 }
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index c2c4a15..f6ba8ff 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -1,28 +1,47 @@
-use std::ffi::CStr;
+use std::{ffi::CStr, marker::PhantomData, ptr};
 
-use libuci_sys::uci_section;
+use libuci_sys::{uci_package, uci_section, uci_to_option};
 
-use crate::{
-    config::{package::PackageRef, NameOrRef},
-    Result, Uci,
-};
+use crate::{Result, Uci};
 
-use super::option::Option;
+use super::{
+    lookup_child,
+    option::{Option, OptionRef},
+    package::PackageRef,
+    NameOrRef, UciListIter,
+};
 
-pub struct SectionRef {
+pub struct SectionRef<'a> {
+    pkg: *const uci_package,
     section: *const uci_section,
+    _lt: &'a PhantomData<()>,
 }
 
-impl SectionRef {
+impl<'a> SectionRef<'a> {
+    pub(crate) unsafe fn new(pkg: *const uci_package, section: *const uci_section) -> Self {
+        Self {
+            pkg,
+            section,
+            _lt: &PhantomData,
+        }
+    }
+
+    pub fn get(self, uci: &'a mut Uci) -> Section<'a> {
+        Section::new(
+            uci,
+            NameOrRef::Ref(unsafe { PackageRef::new(self.pkg) }),
+            NameOrRef::Ref(self),
+        )
+    }
+
     pub fn name(&self) -> Result<&str> {
         let ptr = unsafe { *self.section }.e.name;
         Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?)
     }
-}
 
-impl From<*const uci_section> for SectionRef {
-    fn from(section: *const uci_section) -> Self {
-        Self { section }
+    pub fn r#type(&self) -> Result<&str> {
+        let ptr = unsafe { *self.section }.type_;
+        Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?)
     }
 }
 
@@ -30,15 +49,15 @@ impl From<*const uci_section> for SectionRef {
 /// parent to different [Option]s
 pub struct Section<'a> {
     uci: &'a mut Uci,
-    parent: NameOrRef<String, PackageRef>,
-    section: NameOrRef<(String, String), SectionRef>,
+    parent: NameOrRef<String, PackageRef<'a>>,
+    section: NameOrRef<(String, String), SectionRef<'a>>,
 }
 
 impl<'a> Section<'a> {
     pub(crate) fn new(
         uci: &'a mut Uci,
-        parent: NameOrRef<String, PackageRef>,
-        section: NameOrRef<(String, String), SectionRef>,
+        parent: NameOrRef<String, PackageRef<'a>>,
+        section: NameOrRef<(String, String), SectionRef<'a>>,
     ) -> Self {
         Self {
             uci,
@@ -51,7 +70,7 @@ impl<'a> Section<'a> {
     pub fn name(&mut self) -> Result<&str> {
         match &self.section {
             NameOrRef::Name((name, _)) => Ok(name),
-            NameOrRef::Ref(_) => todo!(),
+            NameOrRef::Ref(section) => section.name(),
         }
     }
 
@@ -59,18 +78,36 @@ impl<'a> Section<'a> {
     pub fn r#type(&mut self) -> Result<&str> {
         match &self.section {
             NameOrRef::Name((_, stype)) => Ok(stype),
-            NameOrRef::Ref(_) => todo!(),
+            NameOrRef::Ref(section) => section.r#type(),
         }
     }
 
     /// returns a specific [Option] by name
     /// also works if the option is not defined yet
-    pub fn option(&mut self, _name: impl AsRef<str>) -> Result<Option> {
-        todo!()
+    pub fn option(&'a mut self, name: impl AsRef<str>) -> Result<Option<'a>> {
+        let name = name.as_ref();
+        let section = match &self.section {
+            NameOrRef::Name(_name) => {
+                return Ok(Option::new(self.uci, NameOrRef::Name(name.to_owned())))
+            }
+            NameOrRef::Ref(section) => section,
+        };
+
+        let option = lookup_child(self.uci, &mut unsafe { *section.section }.options, name)?
+            .map(|elem| unsafe { NameOrRef::Ref(OptionRef::new(uci_to_option(elem))) })
+            .unwrap_or_else(|| NameOrRef::Name(name.to_owned()));
+        Ok(Option::new(self.uci, option))
     }
 
     /// lists all options in this section
-    pub fn options(&mut self) -> Result<impl Iterator<Item = Option>> {
-        Ok(vec![].into_iter())
+    pub fn options(&'a mut self) -> impl Iterator<Item = OptionRef<'a>> {
+        let (_pkg, list) = match &self.section {
+            NameOrRef::Name(_) => (ptr::null(), ptr::null()),
+            NameOrRef::Ref(section) => (
+                section.section,
+                &unsafe { *section.section }.options as *const _,
+            ),
+        };
+        UciListIter::new(list).map(move |elem| unsafe { OptionRef::new(uci_to_option(elem)) })
     }
 }

From 18d9c1a0925cd8caec84da2c550723eeac7eda9e Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Fri, 1 May 2026 23:26:49 +0200
Subject: [PATCH 03/24] Refactor to uci_ptr based approach

---
 libuci-sys/src/lib.rs          |   4 +-
 rust-uci/src/config/mod.rs     | 167 ++++++++++++------------
 rust-uci/src/config/option.rs  | 128 +++++++++++-------
 rust-uci/src/config/package.rs | 114 ++++++----------
 rust-uci/src/config/ptr.rs     | 230 +++++++++++++++++++++++++++++++++
 rust-uci/src/config/section.rs | 126 ++++++------------
 6 files changed, 471 insertions(+), 298 deletions(-)
 create mode 100644 rust-uci/src/config/ptr.rs

diff --git a/libuci-sys/src/lib.rs b/libuci-sys/src/lib.rs
index 371d122..a572955 100644
--- a/libuci-sys/src/lib.rs
+++ b/libuci-sys/src/lib.rs
@@ -35,8 +35,8 @@ pub use bindings::{
     uci_parse_argument, uci_parse_context, uci_parse_option, uci_parse_ptr, uci_parse_section,
     uci_perror, uci_ptr, uci_ptr_UCI_LOOKUP_COMPLETE, uci_rename, uci_reorder_section, uci_revert,
     uci_save, uci_section, uci_set, uci_set_backend, uci_set_confdir, uci_set_savedir, uci_type,
-    uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_SECTION, uci_unload, uci_validate_text,
-    UCI_ERR_NOTFOUND, UCI_OK,
+    uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION,
+    uci_type_UCI_TYPE_UNSPEC, uci_unload, uci_validate_text, UCI_ERR_NOTFOUND, UCI_OK,
 };
 
 #[allow(clippy::ptr_offset_with_cast)]
diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 67a675d..ecf5240 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -1,9 +1,11 @@
-use std::{ffi::CString, option::Option as StdOption, ptr};
-
-use libuci_sys::{
-    list_to_element, uci_element, uci_list, uci_load, uci_lookup_next, uci_to_package,
+use std::{
+    ffi::{c_char, CStr},
+    option::Option as StdOption,
+    sync::{Arc, Mutex},
 };
 
+use libuci_sys::uci_list_configs;
+
 use crate::{
     error::{Error, Result},
     libuci_locked, Uci, UCI_ERR_NOTFOUND, UCI_OK,
@@ -12,108 +14,82 @@ use crate::{
 mod option;
 
 mod package;
-use package::{Package, PackageRef};
+use package::Package;
+
+mod ptr;
+use ptr::UciPtr;
 
 mod section;
 
-#[derive(Clone)]
-pub(crate) enum NameOrRef<N, T> {
-    Name(N),
-    Ref(T),
+/// represents the root of the config tree
+/// It's the parent structure to [Package]s
+pub struct Config {
+    uci: Arc<Mutex<Uci>>,
 }
 
-struct UciListIter {
-    list: *const uci_list,
+impl From<Uci> for Config {
+    fn from(uci: Uci) -> Self {
+        Self {
+            uci: Arc::new(Mutex::new(uci)),
+        }
+    }
 }
 
-impl UciListIter {
-    fn new(list: *const uci_list) -> Self {
-        Self { list }
-    }
+struct PackageIter {
+    uci: Arc<Mutex<Uci>>,
+    ptr: *mut *mut c_char,
 }
 
-impl Iterator for UciListIter {
-    type Item = *const uci_element;
+impl Iterator for PackageIter {
+    type Item = Package<false>;
 
     fn next(&mut self) -> StdOption<Self::Item> {
-        if self.list.is_null() {
+        if self.ptr.is_null() {
             return None;
         }
-
-        let node = unsafe { (*self.list).next };
-        if node.is_null() {
+        let name_ptr = unsafe { *self.ptr };
+        if name_ptr.is_null() {
             return None;
         }
-        if node.cast_const() == self.list {
-            return None;
-        }
-
-        Some(unsafe { list_to_element(node.cast_const()) })
-    }
-}
-
-/// represents the root of the config tree
-/// It's the parent structure to [Package]s
-pub struct Config {
-    uci: Uci,
-}
-
-impl From<Uci> for Config {
-    fn from(uci: Uci) -> Self {
-        Self { uci }
+        self.ptr = unsafe { self.ptr.add(1) };
+        let name = unsafe { CStr::from_ptr(name_ptr.cast()) }.to_str().unwrap();
+        let ptr = UciPtr::new();
+        Some(Package::new(
+            Arc::clone(&self.uci),
+            ptr.with_package_name(name).unwrap(),
+        ))
     }
 }
 
 impl Config {
     pub fn new() -> Result<Self> {
-        Ok(Self { uci: Uci::new()? })
+        Ok(Uci::new()?.into())
     }
 
     /// return a single [Package] by its name
     /// also works if the package is not defined yet
-    pub fn package<'a>(&'a mut self, name: impl AsRef<str>) -> Result<Package<'a>> {
-        let root = (unsafe { *self.uci.ctx }).root;
-        let lookup = lookup_child(&mut self.uci, root.next, &name)?;
-        let lookup = match lookup {
-            None => {
-                let mut pkg = ptr::null_mut();
-                let raw_name = CString::new(name.as_ref())?;
-                let result = unsafe { uci_load(self.uci.ctx, raw_name.as_ptr(), &mut pkg) };
-                handle_error(&mut self.uci, result)?.map(|_| pkg.cast_const())
-            }
-            Some(v) => Some(unsafe { uci_to_package(v) }),
-        };
-        let pkg = lookup
-            .map(|e| NameOrRef::Ref(unsafe { PackageRef::new(e) }))
-            .unwrap_or_else(|| NameOrRef::Name(name.as_ref().to_owned()));
-        Ok(Package::new(&mut self.uci, pkg))
+    pub fn package<'a>(&self, name: impl AsRef<str>) -> Result<Package<false>> {
+        let ptr = ptr::UciPtr::new();
+        let ptr = ptr.with_package_name(name)?;
+        Ok(Package::new(Arc::clone(&self.uci), ptr))
     }
 
     /// list all [Package]s in the config
-    pub fn packages<'a>(&'a mut self) -> impl Iterator<Item = PackageRef<'a>> {
-        // todo: this is broken, since packages are loaded on demand
-        // needs to use `uci_list_configs`
-
-        // Safety: self.uci.ctx is not null
-        let packages = unsafe { (&(*self.uci.ctx).root) as *const _ };
-        // Safety: elem is not null
-        UciListIter::new(packages).map(|elem| unsafe { PackageRef::new(uci_to_package(elem)) })
+    pub fn packages<'a>(&self) -> Result<impl Iterator<Item = Package<false>>> {
+        let mut uci = self.uci.lock().unwrap();
+        let mut list = std::ptr::null_mut();
+        let result = libuci_locked!(uci, { unsafe { uci_list_configs(uci.ctx, &mut list) } });
+        let ptr = match handle_error(&mut uci, result)? {
+            Some(_) => list,
+            None => std::ptr::null_mut(),
+        };
+        Ok(PackageIter {
+            uci: Arc::clone(&self.uci),
+            ptr,
+        })
     }
 }
 
-fn lookup_child(
-    uci: &mut Uci,
-    parent: *mut uci_list,
-    name: impl AsRef<str>,
-) -> Result<StdOption<*mut uci_element>> {
-    let raw = CString::new(name.as_ref())?;
-    let mut elem = ptr::null_mut();
-    let result = libuci_locked!(uci, {
-        unsafe { uci_lookup_next(uci.ctx, &mut elem as *mut _, parent, raw.as_ptr()) }
-    });
-    Ok(handle_error(uci, result)?.map(|_| elem))
-}
-
 fn handle_error(uci: &mut Uci, result: i32) -> Result<Option<()>> {
     match result {
         UCI_OK => Ok(Some(())),
@@ -165,20 +141,43 @@ mod tests {
         )
         .unwrap();
 
-        let mut cfg: Config = uci.into();
-        let mut pkg = cfg.package("wireless").unwrap();
-        let mut sect = pkg.section("wifi-device", "pdev0").unwrap();
-        let mut opt = sect.option("channel").unwrap();
+        let cfg: Config = uci.into();
+        let pkg = cfg.package("wireless").unwrap();
+        let sect = pkg.section("wifi-device", "pdev0").unwrap();
+        let opt = sect.option("channel").unwrap();
         let val = opt.get().unwrap();
         assert_eq!(Some(option::Value::String("auto".into())), val);
     }
 
-    // #[test]
+    #[test]
     fn list_packages() {
-        let mut cfg = Config::new().unwrap();
-        let pkgs = cfg.packages();
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+            ",
+        )
+        .unwrap();
+        std::fs::write(
+            &tmp.path().join("config/network"),
+            "
+            config device 'eth0'
+                    option mtu '1280'
+            ",
+        )
+        .unwrap();
+
+        let cfg: Config = uci.into();
+        let pkgs: Vec<_> = cfg.packages().unwrap().collect();
+        assert_eq!(2, pkgs.len());
         for pkg in pkgs {
-            println!("{}", pkg.name().unwrap());
+            match pkg.name().unwrap() {
+                "wireless" => (),
+                "network" => (),
+                n => panic!("Unexpected name: {}", n),
+            }
         }
     }
 }
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index dbf4474..91b25ec 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,64 +1,34 @@
 use std::{
-    borrow::Cow, collections::btree_map::Values, ffi::CStr, marker::PhantomData,
+    borrow::Cow,
+    ffi::{CStr, CString},
     option::Option as StdOption,
+    sync::{Arc, Mutex},
 };
 
 use libuci_sys::{
-    uci_foreach_element, uci_option, uci_option_type_UCI_TYPE_LIST, uci_option_type_UCI_TYPE_STRING,
+    uci_add_list, uci_foreach_element, uci_option_type_UCI_TYPE_LIST,
+    uci_option_type_UCI_TYPE_STRING, uci_set,
 };
 
-use crate::{config::NameOrRef, error::Error, Result, Uci};
+use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
 
-pub struct OptionRef<'a> {
-    option: *const uci_option,
-    _lt: &'a PhantomData<()>,
-}
-
-impl<'a> OptionRef<'a> {
-    pub(crate) unsafe fn new(option: *const uci_option) -> Self {
-        Self {
-            option,
-            _lt: &PhantomData,
-        }
-    }
-
-    pub fn name(&self) -> Result<&str> {
-        let raw = unsafe { CStr::from_ptr((*self.option).e.name) };
-        Ok(raw.to_str()?)
-    }
-}
+use super::ptr::{UciPtr, PTR_STAGE_OPTION};
 
 /// represents an option within a [Section]
-pub struct Option<'a> {
-    uci: &'a mut Uci,
-    option: NameOrRef<String, OptionRef<'a>>,
+pub struct Option<const L: bool> {
+    uci: Arc<Mutex<Uci>>,
+    ptr: UciPtr<PTR_STAGE_OPTION, L>,
 }
 
-impl<'a> Option<'a> {
-    pub(crate) fn new(uci: &'a mut Uci, option: NameOrRef<String, OptionRef<'a>>) -> Self {
-        Self { uci, option }
-    }
-
-    /// name of the option
-    pub fn name(&mut self) -> Result<&str> {
-        match &self.option {
-            NameOrRef::Name(name) => Ok(name),
-            NameOrRef::Ref(opt) => opt.name(),
-        }
-    }
-
-    /// returns the current value of the option, None if not set
-    pub fn get(&'a mut self) -> Result<StdOption<Value<'a>>> {
-        let opt = match &self.option {
-            NameOrRef::Name(_) => return Ok(None),
-            NameOrRef::Ref(opt) => opt.option,
-        };
+impl<const L: bool> Option<L> {
+    fn get_impl<'a>(ptr: &UciPtr<PTR_STAGE_OPTION, true>) -> Result<Value<'a>> {
+        let opt = ptr.o;
 
         #[allow(non_upper_case_globals)]
         match unsafe { *opt }.type_ {
             uci_option_type_UCI_TYPE_STRING => {
                 let raw = unsafe { CStr::from_ptr((*opt).v.string) };
-                Ok(Some(Value::String(raw.to_str()?.into())))
+                Ok(Value::String(raw.to_str()?.into()))
             }
             uci_option_type_UCI_TYPE_LIST => {
                 let mut result = Vec::new();
@@ -68,12 +38,12 @@ impl<'a> Option<'a> {
                         result.push(raw);
                     })
                 };
-                Ok(Some(Value::List(
+                Ok(Value::List(
                     result
                         .into_iter()
                         .map(|cstr| cstr.to_str().map_err(Into::into).map(Into::into))
                         .collect::<Result<Vec<_>>>()?,
-                )))
+                ))
             }
             t => return Err(Error::Message(format!("Unexpected option type: {t}"))),
         }
@@ -82,8 +52,19 @@ impl<'a> Option<'a> {
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
-    pub fn set(&mut self, _value: Value<'static>) -> Result<()> {
-        todo!()
+    pub fn set(&mut self, value: impl AsRef<str>) -> Result<Option<true>> {
+        let value = CString::new(value.as_ref())?;
+        let mut ptr = self.ptr.clone();
+        ptr.value = value.as_ptr();
+
+        let mut uci = self.uci.lock().unwrap();
+        let result = libuci_locked!(uci, { unsafe { uci_set(uci.ctx, &mut ptr) } });
+        handle_error(&mut uci, result)?;
+
+        Ok(Option::new(
+            Arc::clone(&self.uci),
+            self.ptr.with_update(ptr),
+        ))
     }
 
     /// adds a value to the existing value
@@ -92,8 +73,55 @@ impl<'a> Option<'a> {
     /// - turn a single-value option into a list
     ///
     /// returns the resulting value
-    pub fn add_list(&'a mut self, _value: Value) -> Result<Value<'a>> {
-        todo!()
+    pub fn add_list<'a>(&'a self, value: impl AsRef<str>) -> Result<Option<true>> {
+        let value = CString::new(value.as_ref())?;
+        let mut ptr = self.ptr.clone();
+        ptr.value = value.as_ptr();
+
+        let mut uci = self.uci.lock().unwrap();
+        let result = libuci_locked!(uci, { unsafe { uci_add_list(uci.ctx, &mut ptr) } });
+        handle_error(&mut uci, result)?;
+
+        Ok(Option::new(
+            Arc::clone(&self.uci),
+            self.ptr.with_update(ptr),
+        ))
+    }
+}
+
+impl Option<false> {
+    pub(crate) fn new<const L: bool>(
+        uci: Arc<Mutex<Uci>>,
+        ptr: UciPtr<PTR_STAGE_OPTION, L>,
+    ) -> Option<L> {
+        Option { uci, ptr }
+    }
+
+    /// name of the option
+    pub fn name(&self) -> Result<&str> {
+        Ok(unsafe { CStr::from_ptr((*self.ptr).option) }.to_str()?)
+    }
+
+    /// returns the current value of the option, None if not set
+    pub fn get<'a>(&'a self) -> Result<StdOption<Value<'a>>> {
+        let mut uci = self.uci.lock().unwrap();
+        let ptr = match self.ptr.lookup(&mut uci)? {
+            Some(ptr) => ptr,
+            None => return Ok(None),
+        };
+        Self::get_impl(&ptr).map(Some)
+    }
+}
+
+impl Option<true> {
+    /// name of the option
+    pub fn name(&self) -> Result<&str> {
+        self.ptr.name()
+    }
+
+    /// returns the current value of the option, None if not set
+    pub fn get<'a>(&'a self) -> Result<Value<'a>> {
+        Self::get_impl(&self.ptr)
     }
 }
 
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index daf950b..9c491fc 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -1,98 +1,68 @@
-use std::{ffi::CStr, marker::PhantomData, ptr};
+use std::{
+    ffi::CStr,
+    sync::{Arc, Mutex},
+};
 
-use libuci_sys::{uci_package, uci_to_section};
+use libuci_sys::uci_to_section;
 
 use crate::{Result, Uci};
 
 use super::{
-    lookup_child,
-    section::{Section, SectionRef},
-    NameOrRef, UciListIter,
+    ptr::{UciPtr, PTR_STAGE_PACKAGE},
+    section::Section,
 };
 
-#[derive(Clone)]
-pub struct PackageRef<'a> {
-    pkg: *const uci_package,
-    /// lifetime of UCI context where we got pkg from
-    _lt: &'a PhantomData<()>,
+/// represents a single package in the config tree
+/// parent to different [Section]s
+pub struct Package<const L: bool> {
+    uci: Arc<Mutex<Uci>>,
+    ptr: UciPtr<PTR_STAGE_PACKAGE, L>,
 }
 
-impl<'a> PackageRef<'a> {
-    pub(crate) unsafe fn new(pkg: *const uci_package) -> Self {
-        Self {
-            pkg,
-            _lt: &PhantomData,
-        }
-    }
-
-    pub fn get(self, uci: &'a mut Uci) -> Package<'a> {
-        Package {
-            uci,
-            pkg: NameOrRef::Ref(self),
-        }
+impl Package<false> {
+    pub(crate) fn new<const L: bool>(
+        uci: Arc<Mutex<Uci>>,
+        ptr: UciPtr<PTR_STAGE_PACKAGE, L>,
+    ) -> Package<L> {
+        Package { uci, ptr }
     }
 
     pub fn name(&self) -> Result<&str> {
-        unsafe { CStr::from_ptr((*self.pkg).path) }
-            .to_str()
-            .map_err(Into::into)
+        Ok(unsafe { CStr::from_ptr(self.ptr.package) }.to_str()?)
     }
 }
 
-/// represents a single package in the config tree
-/// parent to different [Section]s
-pub struct Package<'a> {
-    uci: &'a mut Uci,
-    pkg: NameOrRef<String, PackageRef<'a>>,
-}
-
-impl<'a> Package<'a> {
-    pub(crate) fn new(uci: &'a mut Uci, pkg: NameOrRef<String, PackageRef<'a>>) -> Self {
-        Self { uci, pkg }
-    }
-
+impl Package<true> {
     /// name of this package
     pub fn name(&self) -> Result<&str> {
-        match &self.pkg {
-            NameOrRef::Name(name) => Ok(name),
-            NameOrRef::Ref(pkg) => pkg.name(),
-        }
+        self.ptr.name()
     }
 
+    /// list all [Section]s in this package
+    pub fn sections(&self) -> impl Iterator<Item = Section<true>> + use<'_> {
+        let uci = Arc::clone(&self.uci);
+        self.ptr.children().map(move |elem| {
+            Section::new(
+                Arc::clone(&uci),
+                self.ptr
+                    .with_section(unsafe { uci_to_section(elem).cast_mut() }),
+            )
+        })
+    }
+}
+
+impl<const L: bool> Package<L> {
     /// return a single [Section] by its name
     /// also works if the section is not defined yet
     pub fn section(
-        &'a mut self,
-        section_type: impl AsRef<str>,
+        &self,
+        _type_: impl AsRef<str>,
         name: impl AsRef<str>,
-    ) -> Result<Section<'a>> {
-        let name = name.as_ref();
-        let section_type = section_type.as_ref();
+    ) -> Result<Section<false>> {
+        // todo: constrain lookup by section type
+        // let type_ = type_.as_ref();
 
-        let pkg = match &self.pkg {
-            NameOrRef::Name(_) => {
-                return Ok(Section::new(
-                    self.uci,
-                    self.pkg.clone(),
-                    NameOrRef::Name((name.to_owned(), section_type.to_owned())),
-                ))
-            }
-            NameOrRef::Ref(pkg) => pkg,
-        };
-
-        let section = lookup_child(self.uci, &mut unsafe { *pkg.pkg }.sections, name)?
-            .map(|ptr| NameOrRef::Ref(unsafe { SectionRef::new(pkg.pkg, uci_to_section(ptr)) }))
-            .unwrap_or_else(|| NameOrRef::Name((name.to_owned(), section_type.to_owned())));
-        Ok(Section::new(self.uci, self.pkg.clone(), section))
-    }
-
-    /// list all [Section]s in this package
-    pub fn sections(&'a mut self) -> impl Iterator<Item = SectionRef<'a>> {
-        let (pkg, list) = match &self.pkg {
-            NameOrRef::Name(_) => (ptr::null(), ptr::null()),
-            NameOrRef::Ref(pkg) => (pkg.pkg, &unsafe { *pkg.pkg }.sections as *const _),
-        };
-        UciListIter::new(list)
-            .map(move |elem| unsafe { SectionRef::new(pkg, uci_to_section(elem)) })
+        let ptr = self.ptr.with_section_name(name)?;
+        Ok(Section::new(Arc::clone(&self.uci), ptr))
     }
 }
diff --git a/rust-uci/src/config/ptr.rs b/rust-uci/src/config/ptr.rs
new file mode 100644
index 0000000..5eb3e67
--- /dev/null
+++ b/rust-uci/src/config/ptr.rs
@@ -0,0 +1,230 @@
+use std::{
+    ffi::{CStr, CString},
+    iter::once,
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+    option::Option as StdOption,
+    ptr,
+    sync::Arc,
+};
+
+use libuci_sys::{
+    list_to_element, uci_element, uci_list, uci_lookup_ptr, uci_option, uci_package, uci_ptr,
+    uci_ptr_UCI_LOOKUP_COMPLETE, uci_section, uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_PACKAGE,
+    uci_type_UCI_TYPE_SECTION, uci_type_UCI_TYPE_UNSPEC,
+};
+
+use crate::{config::handle_error, libuci_locked, Result, Uci};
+
+struct UciListIter<'a> {
+    list: *const uci_list,
+    _lt: &'a PhantomData<()>,
+}
+
+impl<'a> UciListIter<'a> {
+    fn new(list: *const uci_list) -> Self {
+        Self {
+            list,
+            _lt: &PhantomData,
+        }
+    }
+}
+
+impl<'a> Iterator for UciListIter<'a> {
+    type Item = *const uci_element;
+
+    fn next(&mut self) -> StdOption<Self::Item> {
+        if self.list.is_null() {
+            return None;
+        }
+
+        let node = unsafe { (*self.list).next };
+        if node.is_null() {
+            return None;
+        }
+        if node.cast_const() == self.list {
+            return None;
+        }
+
+        Some(unsafe { list_to_element(node.cast_const()) })
+    }
+}
+
+pub(crate) const PTR_STAGE_INIT: usize = 0;
+pub(crate) const PTR_STAGE_PACKAGE: usize = 1;
+pub(crate) const PTR_STAGE_SECTION: usize = 2;
+pub(crate) const PTR_STAGE_OPTION: usize = 3;
+
+pub(crate) struct UciPtr<const S: usize, const L: bool> {
+    ptr: uci_ptr,
+    data: Vec<Arc<CString>>,
+}
+
+impl<const S: usize, const L: bool> Deref for UciPtr<S, L> {
+    type Target = uci_ptr;
+
+    fn deref(&self) -> &Self::Target {
+        &self.ptr
+    }
+}
+
+impl<const S: usize, const L: bool> DerefMut for UciPtr<S, L> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.ptr
+    }
+}
+
+impl UciPtr<PTR_STAGE_INIT, false> {
+    pub fn new() -> Self {
+        let ptr = uci_ptr {
+            target: uci_type_UCI_TYPE_UNSPEC,
+            flags: 0,
+            p: ptr::null_mut(),
+            s: ptr::null_mut(),
+            o: ptr::null_mut(),
+            last: ptr::null_mut(),
+            package: ptr::null(),
+            section: ptr::null(),
+            option: ptr::null(),
+            value: ptr::null(),
+        };
+        Self {
+            ptr,
+            data: Vec::new(),
+        }
+    }
+
+    pub fn with_package(&self, pkg: *mut uci_package) -> UciPtr<PTR_STAGE_PACKAGE, true> {
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_PACKAGE;
+        ptr.p = pkg;
+        ptr.last = &mut unsafe { *pkg }.e;
+        UciPtr {
+            ptr,
+            data: Vec::new(),
+        }
+    }
+
+    pub fn with_package_name(
+        &self,
+        name: impl AsRef<str>,
+    ) -> Result<UciPtr<PTR_STAGE_PACKAGE, false>> {
+        let name = CString::new(name.as_ref())?;
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_PACKAGE;
+        ptr.package = name.as_ptr();
+        Ok(UciPtr {
+            ptr,
+            data: vec![Arc::new(name)],
+        })
+    }
+}
+
+impl UciPtr<PTR_STAGE_PACKAGE, true> {
+    pub fn with_section(&self, section: *mut uci_section) -> UciPtr<PTR_STAGE_SECTION, true> {
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_SECTION;
+        ptr.s = section;
+        ptr.last = &mut unsafe { *section }.e;
+        UciPtr {
+            ptr,
+            data: self.data.iter().map(Arc::clone).collect(),
+        }
+    }
+}
+
+impl<const L: bool> UciPtr<PTR_STAGE_PACKAGE, L> {
+    pub fn with_section_name(
+        &self,
+        name: impl AsRef<str>,
+    ) -> Result<UciPtr<PTR_STAGE_SECTION, false>> {
+        let name = CString::new(name.as_ref())?;
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_SECTION;
+        ptr.section = name.as_ptr();
+        Ok(UciPtr {
+            ptr,
+            data: self
+                .data
+                .iter()
+                .map(Arc::clone)
+                .chain(once(Arc::new(name)))
+                .collect(),
+        })
+    }
+}
+
+impl UciPtr<PTR_STAGE_SECTION, true> {
+    pub fn with_option(&self, opt: *mut uci_option) -> UciPtr<PTR_STAGE_OPTION, true> {
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_OPTION;
+        ptr.o = opt;
+        ptr.last = &mut unsafe { *opt }.e;
+        UciPtr {
+            ptr,
+            data: self.data.iter().map(Arc::clone).collect(),
+        }
+    }
+}
+
+impl<const L: bool> UciPtr<PTR_STAGE_SECTION, L> {
+    pub fn with_option_name(
+        &self,
+        name: impl AsRef<str>,
+    ) -> Result<UciPtr<PTR_STAGE_OPTION, false>> {
+        let name = CString::new(name.as_ref())?;
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_OPTION;
+        ptr.option = name.as_ptr();
+        Ok(UciPtr {
+            ptr,
+            data: self
+                .data
+                .iter()
+                .map(Arc::clone)
+                .chain(once(Arc::new(name)))
+                .collect(),
+        })
+    }
+}
+
+impl<const L: bool> UciPtr<PTR_STAGE_OPTION, L> {
+    pub fn with_update(&self, ptr: uci_ptr) -> UciPtr<PTR_STAGE_OPTION, true> {
+        if ptr.target != uci_type_UCI_TYPE_OPTION {
+            panic!("Invalid target, expected Option, got {}", ptr.target);
+        }
+        if ptr.p.is_null() || ptr.s.is_null() || ptr.o.is_null() {
+            panic!("Invalid uci_ptr: not fully looked up");
+        }
+        if ptr.flags & uci_ptr_UCI_LOOKUP_COMPLETE == 0 {
+            panic!("Invalid uci_ptr: lookup not complete");
+        }
+        UciPtr {
+            ptr,
+            data: self.data.iter().map(Arc::clone).collect(),
+        }
+    }
+}
+
+impl<const S: usize> UciPtr<S, true> {
+    pub fn name(&self) -> Result<&str> {
+        Ok(unsafe { CStr::from_ptr((*self.ptr.last).name) }.to_str()?)
+    }
+
+    pub fn children<'a>(&'a self) -> impl Iterator<Item = *const uci_element> + 'a {
+        UciListIter::new(&unsafe { *self.last }.list)
+    }
+}
+
+impl<const S: usize> UciPtr<S, false> {
+    pub fn lookup(&self, uci: &mut Uci) -> Result<StdOption<UciPtr<S, true>>> {
+        let mut ptr = self.ptr.clone();
+        let result = libuci_locked!(uci, {
+            unsafe { uci_lookup_ptr(uci.ctx, &mut ptr, ptr::null_mut(), true) }
+        });
+        Ok(handle_error(uci, result)?.map(|_| UciPtr {
+            ptr,
+            data: self.data.iter().map(Arc::clone).collect(),
+        }))
+    }
+}
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index f6ba8ff..cd053de 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -1,113 +1,59 @@
-use std::{ffi::CStr, marker::PhantomData, ptr};
+use std::{
+    ffi::CStr,
+    sync::{Arc, Mutex},
+};
 
-use libuci_sys::{uci_package, uci_section, uci_to_option};
+use libuci_sys::uci_to_option;
 
 use crate::{Result, Uci};
 
 use super::{
-    lookup_child,
-    option::{Option, OptionRef},
-    package::PackageRef,
-    NameOrRef, UciListIter,
+    option::Option,
+    ptr::{UciPtr, PTR_STAGE_SECTION},
 };
 
-pub struct SectionRef<'a> {
-    pkg: *const uci_package,
-    section: *const uci_section,
-    _lt: &'a PhantomData<()>,
-}
-
-impl<'a> SectionRef<'a> {
-    pub(crate) unsafe fn new(pkg: *const uci_package, section: *const uci_section) -> Self {
-        Self {
-            pkg,
-            section,
-            _lt: &PhantomData,
-        }
-    }
-
-    pub fn get(self, uci: &'a mut Uci) -> Section<'a> {
-        Section::new(
-            uci,
-            NameOrRef::Ref(unsafe { PackageRef::new(self.pkg) }),
-            NameOrRef::Ref(self),
-        )
-    }
-
-    pub fn name(&self) -> Result<&str> {
-        let ptr = unsafe { *self.section }.e.name;
-        Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?)
-    }
-
-    pub fn r#type(&self) -> Result<&str> {
-        let ptr = unsafe { *self.section }.type_;
-        Ok(unsafe { CStr::from_ptr(ptr) }.to_str()?)
-    }
-}
-
 /// represents a single section
 /// parent to different [Option]s
-pub struct Section<'a> {
-    uci: &'a mut Uci,
-    parent: NameOrRef<String, PackageRef<'a>>,
-    section: NameOrRef<(String, String), SectionRef<'a>>,
+pub struct Section<const L: bool> {
+    uci: Arc<Mutex<Uci>>,
+    ptr: UciPtr<PTR_STAGE_SECTION, L>,
 }
 
-impl<'a> Section<'a> {
-    pub(crate) fn new(
-        uci: &'a mut Uci,
-        parent: NameOrRef<String, PackageRef<'a>>,
-        section: NameOrRef<(String, String), SectionRef<'a>>,
-    ) -> Self {
-        Self {
-            uci,
-            parent,
-            section,
-        }
+impl<const L: bool> Section<L> {
+    pub(crate) fn new(uci: Arc<Mutex<Uci>>, ptr: UciPtr<PTR_STAGE_SECTION, L>) -> Self {
+        Self { uci, ptr }
     }
+}
 
+impl Section<true> {
     /// returns the name of named sections, otherwise None
-    pub fn name(&mut self) -> Result<&str> {
-        match &self.section {
-            NameOrRef::Name((name, _)) => Ok(name),
-            NameOrRef::Ref(section) => section.name(),
-        }
+    pub fn name(&self) -> Result<&str> {
+        self.ptr.name()
     }
 
     /// returns the type of the section
-    pub fn r#type(&mut self) -> Result<&str> {
-        match &self.section {
-            NameOrRef::Name((_, stype)) => Ok(stype),
-            NameOrRef::Ref(section) => section.r#type(),
-        }
+    pub fn type_(&mut self) -> Result<&str> {
+        Ok(unsafe { CStr::from_ptr((*self.ptr.s).type_) }.to_str()?)
     }
 
-    /// returns a specific [Option] by name
-    /// also works if the option is not defined yet
-    pub fn option(&'a mut self, name: impl AsRef<str>) -> Result<Option<'a>> {
-        let name = name.as_ref();
-        let section = match &self.section {
-            NameOrRef::Name(_name) => {
-                return Ok(Option::new(self.uci, NameOrRef::Name(name.to_owned())))
-            }
-            NameOrRef::Ref(section) => section,
-        };
-
-        let option = lookup_child(self.uci, &mut unsafe { *section.section }.options, name)?
-            .map(|elem| unsafe { NameOrRef::Ref(OptionRef::new(uci_to_option(elem))) })
-            .unwrap_or_else(|| NameOrRef::Name(name.to_owned()));
-        Ok(Option::new(self.uci, option))
+    /// lists all options in this section
+    pub fn options(&self) -> impl Iterator<Item = Option<true>> + use<'_> {
+        let uci = Arc::clone(&self.uci);
+        self.ptr.children().map(move |elem| {
+            Option::new(
+                Arc::clone(&uci),
+                self.ptr
+                    .with_option(unsafe { uci_to_option(elem).cast_mut() }),
+            )
+        })
     }
+}
 
-    /// lists all options in this section
-    pub fn options(&'a mut self) -> impl Iterator<Item = OptionRef<'a>> {
-        let (_pkg, list) = match &self.section {
-            NameOrRef::Name(_) => (ptr::null(), ptr::null()),
-            NameOrRef::Ref(section) => (
-                section.section,
-                &unsafe { *section.section }.options as *const _,
-            ),
-        };
-        UciListIter::new(list).map(move |elem| unsafe { OptionRef::new(uci_to_option(elem)) })
+impl<const L: bool> Section<L> {
+    /// returns a specific [Option] by name
+    /// also works if the option is not defined yet
+    pub fn option(&self, name: impl AsRef<str>) -> Result<Option<false>> {
+        let ptr = self.ptr.with_option_name(name)?;
+        Ok(Option::new(Arc::clone(&self.uci), ptr))
     }
 }

From dbbf8094f212e74a4657c7dfabd08b2118862705 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 01:12:24 +0200
Subject: [PATCH 04/24] Simplify interior mutability

---
 rust-uci/src/config/mod.rs     | 43 ++++++++++++++---
 rust-uci/src/config/option.rs  | 32 +++++--------
 rust-uci/src/config/package.rs | 37 ++++++++-------
 rust-uci/src/config/ptr.rs     | 84 ++++++++++++++++++++++++----------
 rust-uci/src/config/section.rs | 22 ++++-----
 5 files changed, 138 insertions(+), 80 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index ecf5240..abfe88d 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -53,11 +53,8 @@ impl Iterator for PackageIter {
         }
         self.ptr = unsafe { self.ptr.add(1) };
         let name = unsafe { CStr::from_ptr(name_ptr.cast()) }.to_str().unwrap();
-        let ptr = UciPtr::new();
-        Some(Package::new(
-            Arc::clone(&self.uci),
-            ptr.with_package_name(name).unwrap(),
-        ))
+        let ptr = UciPtr::new(Arc::clone(&self.uci));
+        Some(Package::new(ptr.with_package_name(name).unwrap()))
     }
 }
 
@@ -69,9 +66,9 @@ impl Config {
     /// return a single [Package] by its name
     /// also works if the package is not defined yet
     pub fn package<'a>(&self, name: impl AsRef<str>) -> Result<Package<false>> {
-        let ptr = ptr::UciPtr::new();
+        let ptr = ptr::UciPtr::new(Arc::clone(&self.uci));
         let ptr = ptr.with_package_name(name)?;
-        Ok(Package::new(Arc::clone(&self.uci), ptr))
+        Ok(Package::new(ptr))
     }
 
     /// list all [Package]s in the config
@@ -180,4 +177,36 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn ptr_mutability() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+            ",
+        )
+        .unwrap();
+
+        let cfg: Config = uci.into();
+        let pkg = cfg.package("wireless").unwrap();
+        for section in pkg.sections().unwrap() {
+            let opt = section.option("channel").unwrap();
+            let updated = opt.set("foo").unwrap();
+            assert_eq!(opt.get().unwrap(), Some(updated.get().unwrap()));
+        }
+
+        let opt = cfg
+            .package("wireless")
+            .unwrap()
+            .section("wifi-device", "pdev1")
+            .unwrap()
+            .option("channel")
+            .unwrap();
+        let updated1 = opt.set("foo").unwrap();
+        let updated2 = opt.set("auto").unwrap();
+        println!("done!");
+    }
 }
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 91b25ec..3eb1f85 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,8 +1,8 @@
 use std::{
     borrow::Cow,
     ffi::{CStr, CString},
+    iter,
     option::Option as StdOption,
-    sync::{Arc, Mutex},
 };
 
 use libuci_sys::{
@@ -10,13 +10,13 @@ use libuci_sys::{
     uci_option_type_UCI_TYPE_STRING, uci_set,
 };
 
-use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
+use crate::{config::handle_error, error::Error, libuci_locked, Result};
 
 use super::ptr::{UciPtr, PTR_STAGE_OPTION};
 
 /// represents an option within a [Section]
+// todo: get rid of const generic, use enum
 pub struct Option<const L: bool> {
-    uci: Arc<Mutex<Uci>>,
     ptr: UciPtr<PTR_STAGE_OPTION, L>,
 }
 
@@ -52,19 +52,16 @@ impl<const L: bool> Option<L> {
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
-    pub fn set(&mut self, value: impl AsRef<str>) -> Result<Option<true>> {
+    pub fn set(&self, value: impl AsRef<str>) -> Result<Option<true>> {
         let value = CString::new(value.as_ref())?;
         let mut ptr = self.ptr.clone();
         ptr.value = value.as_ptr();
 
-        let mut uci = self.uci.lock().unwrap();
+        let mut uci = self.ptr.uci.lock().unwrap();
         let result = libuci_locked!(uci, { unsafe { uci_set(uci.ctx, &mut ptr) } });
         handle_error(&mut uci, result)?;
 
-        Ok(Option::new(
-            Arc::clone(&self.uci),
-            self.ptr.with_update(ptr),
-        ))
+        Ok(Option::new(self.ptr.with_update(ptr, iter::once(value))))
     }
 
     /// adds a value to the existing value
@@ -78,23 +75,17 @@ impl<const L: bool> Option<L> {
         let mut ptr = self.ptr.clone();
         ptr.value = value.as_ptr();
 
-        let mut uci = self.uci.lock().unwrap();
+        let mut uci = self.ptr.uci.lock().unwrap();
         let result = libuci_locked!(uci, { unsafe { uci_add_list(uci.ctx, &mut ptr) } });
         handle_error(&mut uci, result)?;
 
-        Ok(Option::new(
-            Arc::clone(&self.uci),
-            self.ptr.with_update(ptr),
-        ))
+        Ok(Option::new(self.ptr.with_update(ptr, iter::once(value))))
     }
 }
 
 impl Option<false> {
-    pub(crate) fn new<const L: bool>(
-        uci: Arc<Mutex<Uci>>,
-        ptr: UciPtr<PTR_STAGE_OPTION, L>,
-    ) -> Option<L> {
-        Option { uci, ptr }
+    pub(crate) fn new<const L: bool>(ptr: UciPtr<PTR_STAGE_OPTION, L>) -> Option<L> {
+        Option { ptr }
     }
 
     /// name of the option
@@ -104,8 +95,7 @@ impl Option<false> {
 
     /// returns the current value of the option, None if not set
     pub fn get<'a>(&'a self) -> Result<StdOption<Value<'a>>> {
-        let mut uci = self.uci.lock().unwrap();
-        let ptr = match self.ptr.lookup(&mut uci)? {
+        let ptr = match self.ptr.lookup()? {
             Some(ptr) => ptr,
             None => return Ok(None),
         };
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 9c491fc..767485d 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -1,35 +1,41 @@
-use std::{
-    ffi::CStr,
-    sync::{Arc, Mutex},
-};
+use std::{ffi::CStr, sync::Arc};
 
 use libuci_sys::uci_to_section;
 
-use crate::{Result, Uci};
+use crate::Result;
 
 use super::{
-    ptr::{UciPtr, PTR_STAGE_PACKAGE},
+    ptr::{UciListIter, UciPtr, PTR_STAGE_PACKAGE},
     section::Section,
 };
 
 /// represents a single package in the config tree
 /// parent to different [Section]s
+// todo: get rid of const generic, use enum
 pub struct Package<const L: bool> {
-    uci: Arc<Mutex<Uci>>,
     ptr: UciPtr<PTR_STAGE_PACKAGE, L>,
 }
 
 impl Package<false> {
-    pub(crate) fn new<const L: bool>(
-        uci: Arc<Mutex<Uci>>,
-        ptr: UciPtr<PTR_STAGE_PACKAGE, L>,
-    ) -> Package<L> {
-        Package { uci, ptr }
+    pub(crate) fn new<const L: bool>(ptr: UciPtr<PTR_STAGE_PACKAGE, L>) -> Package<L> {
+        Package { ptr }
     }
 
     pub fn name(&self) -> Result<&str> {
         Ok(unsafe { CStr::from_ptr(self.ptr.package) }.to_str()?)
     }
+
+    pub fn sections(&self) -> Result<impl Iterator<Item = Section<true>> + use<'_>> {
+        let ptr = match self.ptr.lookup()? {
+            Some(ptr) => ptr,
+            None => todo!(),
+        };
+        let iter = unsafe { UciListIter::new(&(*ptr.p).sections) };
+        let ptr_inner = Arc::new(ptr);
+        Ok(iter.map(move |elem| {
+            Section::new(ptr_inner.with_section(unsafe { uci_to_section(elem).cast_mut() }))
+        }))
+    }
 }
 
 impl Package<true> {
@@ -40,10 +46,9 @@ impl Package<true> {
 
     /// list all [Section]s in this package
     pub fn sections(&self) -> impl Iterator<Item = Section<true>> + use<'_> {
-        let uci = Arc::clone(&self.uci);
-        self.ptr.children().map(move |elem| {
+        let iter = unsafe { UciListIter::new(&(*self.ptr.p).sections) };
+        iter.map(move |elem| {
             Section::new(
-                Arc::clone(&uci),
                 self.ptr
                     .with_section(unsafe { uci_to_section(elem).cast_mut() }),
             )
@@ -63,6 +68,6 @@ impl<const L: bool> Package<L> {
         // let type_ = type_.as_ref();
 
         let ptr = self.ptr.with_section_name(name)?;
-        Ok(Section::new(Arc::clone(&self.uci), ptr))
+        Ok(Section::new(ptr))
     }
 }
diff --git a/rust-uci/src/config/ptr.rs b/rust-uci/src/config/ptr.rs
index 5eb3e67..8e2ec92 100644
--- a/rust-uci/src/config/ptr.rs
+++ b/rust-uci/src/config/ptr.rs
@@ -5,7 +5,7 @@ use std::{
     ops::{Deref, DerefMut},
     option::Option as StdOption,
     ptr,
-    sync::Arc,
+    sync::{Arc, Mutex},
 };
 
 use libuci_sys::{
@@ -16,15 +16,18 @@ use libuci_sys::{
 
 use crate::{config::handle_error, libuci_locked, Result, Uci};
 
-struct UciListIter<'a> {
+pub(super) struct UciListIter<'a> {
     list: *const uci_list,
+    ptr: *const uci_list,
     _lt: &'a PhantomData<()>,
 }
 
 impl<'a> UciListIter<'a> {
-    fn new(list: *const uci_list) -> Self {
+    /// Safety: list cannot be null
+    pub unsafe fn new(list: *const uci_list) -> Self {
         Self {
             list,
+            ptr: unsafe { *list }.next,
             _lt: &PhantomData,
         }
     }
@@ -34,19 +37,17 @@ impl<'a> Iterator for UciListIter<'a> {
     type Item = *const uci_element;
 
     fn next(&mut self) -> StdOption<Self::Item> {
-        if self.list.is_null() {
+        if self.ptr.is_null() {
             return None;
         }
-
-        let node = unsafe { (*self.list).next };
-        if node.is_null() {
-            return None;
-        }
-        if node.cast_const() == self.list {
+        if self.ptr == self.list {
             return None;
         }
 
-        Some(unsafe { list_to_element(node.cast_const()) })
+        let elem = unsafe { list_to_element(self.ptr) };
+        self.ptr = unsafe { *elem }.list.next;
+
+        Some(elem)
     }
 }
 
@@ -56,6 +57,7 @@ pub(crate) const PTR_STAGE_SECTION: usize = 2;
 pub(crate) const PTR_STAGE_OPTION: usize = 3;
 
 pub(crate) struct UciPtr<const S: usize, const L: bool> {
+    pub(crate) uci: Arc<Mutex<Uci>>,
     ptr: uci_ptr,
     data: Vec<Arc<CString>>,
 }
@@ -75,7 +77,7 @@ impl<const S: usize, const L: bool> DerefMut for UciPtr<S, L> {
 }
 
 impl UciPtr<PTR_STAGE_INIT, false> {
-    pub fn new() -> Self {
+    pub fn new(uci: Arc<Mutex<Uci>>) -> Self {
         let ptr = uci_ptr {
             target: uci_type_UCI_TYPE_UNSPEC,
             flags: 0,
@@ -89,6 +91,7 @@ impl UciPtr<PTR_STAGE_INIT, false> {
             value: ptr::null(),
         };
         Self {
+            uci,
             ptr,
             data: Vec::new(),
         }
@@ -98,8 +101,8 @@ impl UciPtr<PTR_STAGE_INIT, false> {
         let mut ptr = self.ptr.clone();
         ptr.target = uci_type_UCI_TYPE_PACKAGE;
         ptr.p = pkg;
-        ptr.last = &mut unsafe { *pkg }.e;
         UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: Vec::new(),
         }
@@ -114,6 +117,7 @@ impl UciPtr<PTR_STAGE_INIT, false> {
         ptr.target = uci_type_UCI_TYPE_PACKAGE;
         ptr.package = name.as_ptr();
         Ok(UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: vec![Arc::new(name)],
         })
@@ -125,8 +129,8 @@ impl UciPtr<PTR_STAGE_PACKAGE, true> {
         let mut ptr = self.ptr.clone();
         ptr.target = uci_type_UCI_TYPE_SECTION;
         ptr.s = section;
-        ptr.last = &mut unsafe { *section }.e;
         UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: self.data.iter().map(Arc::clone).collect(),
         }
@@ -143,6 +147,7 @@ impl<const L: bool> UciPtr<PTR_STAGE_PACKAGE, L> {
         ptr.target = uci_type_UCI_TYPE_SECTION;
         ptr.section = name.as_ptr();
         Ok(UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: self
                 .data
@@ -159,8 +164,8 @@ impl UciPtr<PTR_STAGE_SECTION, true> {
         let mut ptr = self.ptr.clone();
         ptr.target = uci_type_UCI_TYPE_OPTION;
         ptr.o = opt;
-        ptr.last = &mut unsafe { *opt }.e;
         UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: self.data.iter().map(Arc::clone).collect(),
         }
@@ -177,6 +182,7 @@ impl<const L: bool> UciPtr<PTR_STAGE_SECTION, L> {
         ptr.target = uci_type_UCI_TYPE_OPTION;
         ptr.option = name.as_ptr();
         Ok(UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: self
                 .data
@@ -189,7 +195,11 @@ impl<const L: bool> UciPtr<PTR_STAGE_SECTION, L> {
 }
 
 impl<const L: bool> UciPtr<PTR_STAGE_OPTION, L> {
-    pub fn with_update(&self, ptr: uci_ptr) -> UciPtr<PTR_STAGE_OPTION, true> {
+    pub fn with_update(
+        &self,
+        ptr: uci_ptr,
+        extra_data: impl Iterator<Item = CString>,
+    ) -> UciPtr<PTR_STAGE_OPTION, true> {
         if ptr.target != uci_type_UCI_TYPE_OPTION {
             panic!("Invalid target, expected Option, got {}", ptr.target);
         }
@@ -200,31 +210,59 @@ impl<const L: bool> UciPtr<PTR_STAGE_OPTION, L> {
             panic!("Invalid uci_ptr: lookup not complete");
         }
         UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
-            data: self.data.iter().map(Arc::clone).collect(),
+            data: self
+                .data
+                .iter()
+                .map(Arc::clone)
+                .chain(extra_data.map(Arc::new))
+                .collect(),
         }
     }
 }
 
+struct CapturingIter<T, I> {
+    inner: I,
+    capture: T,
+}
+
+impl<T, I> Iterator for CapturingIter<T, I>
+where
+    I: Iterator,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> StdOption<Self::Item> {
+        self.inner.next()
+    }
+}
+
 impl<const S: usize> UciPtr<S, true> {
     pub fn name(&self) -> Result<&str> {
         Ok(unsafe { CStr::from_ptr((*self.ptr.last).name) }.to_str()?)
     }
-
-    pub fn children<'a>(&'a self) -> impl Iterator<Item = *const uci_element> + 'a {
-        UciListIter::new(&unsafe { *self.last }.list)
-    }
 }
 
 impl<const S: usize> UciPtr<S, false> {
-    pub fn lookup(&self, uci: &mut Uci) -> Result<StdOption<UciPtr<S, true>>> {
+    pub fn lookup(&self) -> Result<StdOption<UciPtr<S, true>>> {
         let mut ptr = self.ptr.clone();
+        let mut uci = self.uci.lock().unwrap();
         let result = libuci_locked!(uci, {
             unsafe { uci_lookup_ptr(uci.ctx, &mut ptr, ptr::null_mut(), true) }
         });
-        Ok(handle_error(uci, result)?.map(|_| UciPtr {
+        Ok(handle_error(&mut uci, result)?.map(|_| UciPtr {
+            uci: Arc::clone(&self.uci),
             ptr,
             data: self.data.iter().map(Arc::clone).collect(),
         }))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn iterator() {
+        // let iter = unsafe { UciListIter::new(list) };
+    }
+}
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index cd053de..f9e1caa 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -1,27 +1,24 @@
-use std::{
-    ffi::CStr,
-    sync::{Arc, Mutex},
-};
+use std::ffi::CStr;
 
 use libuci_sys::uci_to_option;
 
-use crate::{Result, Uci};
+use crate::Result;
 
 use super::{
     option::Option,
-    ptr::{UciPtr, PTR_STAGE_SECTION},
+    ptr::{UciListIter, UciPtr, PTR_STAGE_SECTION},
 };
 
 /// represents a single section
 /// parent to different [Option]s
+// todo: get rid of const generic, use enum
 pub struct Section<const L: bool> {
-    uci: Arc<Mutex<Uci>>,
     ptr: UciPtr<PTR_STAGE_SECTION, L>,
 }
 
 impl<const L: bool> Section<L> {
-    pub(crate) fn new(uci: Arc<Mutex<Uci>>, ptr: UciPtr<PTR_STAGE_SECTION, L>) -> Self {
-        Self { uci, ptr }
+    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_SECTION, L>) -> Self {
+        Self { ptr }
     }
 }
 
@@ -38,10 +35,9 @@ impl Section<true> {
 
     /// lists all options in this section
     pub fn options(&self) -> impl Iterator<Item = Option<true>> + use<'_> {
-        let uci = Arc::clone(&self.uci);
-        self.ptr.children().map(move |elem| {
+        let iter = unsafe { UciListIter::new(&(*self.ptr.s).options) };
+        iter.map(move |elem| {
             Option::new(
-                Arc::clone(&uci),
                 self.ptr
                     .with_option(unsafe { uci_to_option(elem).cast_mut() }),
             )
@@ -54,6 +50,6 @@ impl<const L: bool> Section<L> {
     /// also works if the option is not defined yet
     pub fn option(&self, name: impl AsRef<str>) -> Result<Option<false>> {
         let ptr = self.ptr.with_option_name(name)?;
-        Ok(Option::new(Arc::clone(&self.uci), ptr))
+        Ok(Option::new(ptr))
     }
 }

From 8302f79a6bc1f4da82b6ea7ad9e0bcfc07bf12f5 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 02:33:29 +0200
Subject: [PATCH 05/24] Avoid keeping pointers from uci around

---
 rust-uci/src/config/mod.rs     |  19 ++---
 rust-uci/src/config/option.rs  | 128 +++++++++++++--------------------
 rust-uci/src/config/package.rs |  44 +++---------
 rust-uci/src/config/ptr.rs     | 113 +++++------------------------
 rust-uci/src/config/section.rs |  66 +++++++++++------
 5 files changed, 128 insertions(+), 242 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index abfe88d..d39620b 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -41,7 +41,7 @@ struct PackageIter {
 }
 
 impl Iterator for PackageIter {
-    type Item = Package<false>;
+    type Item = Package;
 
     fn next(&mut self) -> StdOption<Self::Item> {
         if self.ptr.is_null() {
@@ -65,14 +65,14 @@ impl Config {
 
     /// return a single [Package] by its name
     /// also works if the package is not defined yet
-    pub fn package<'a>(&self, name: impl AsRef<str>) -> Result<Package<false>> {
+    pub fn package<'a>(&self, name: impl AsRef<str>) -> Result<Package> {
         let ptr = ptr::UciPtr::new(Arc::clone(&self.uci));
         let ptr = ptr.with_package_name(name)?;
         Ok(Package::new(ptr))
     }
 
     /// list all [Package]s in the config
-    pub fn packages<'a>(&self) -> Result<impl Iterator<Item = Package<false>>> {
+    pub fn packages<'a>(&self) -> Result<impl Iterator<Item = Package>> {
         let mut uci = self.uci.lock().unwrap();
         let mut list = std::ptr::null_mut();
         let result = libuci_locked!(uci, { unsafe { uci_list_configs(uci.ctx, &mut list) } });
@@ -106,7 +106,7 @@ fn handle_error(uci: &mut Uci, result: i32) -> Result<Option<()>> {
 mod tests {
     use tempfile::{tempdir, TempDir};
 
-    use super::*;
+    use super::{option::Value, *};
 
     fn setup_uci() -> Result<(Uci, TempDir)> {
         let mut uci = Uci::new()?;
@@ -140,7 +140,7 @@ mod tests {
 
         let cfg: Config = uci.into();
         let pkg = cfg.package("wireless").unwrap();
-        let sect = pkg.section("wifi-device", "pdev0").unwrap();
+        let sect = pkg.section("pdev0").unwrap();
         let opt = sect.option("channel").unwrap();
         let val = opt.get().unwrap();
         assert_eq!(Some(option::Value::String("auto".into())), val);
@@ -194,14 +194,17 @@ mod tests {
         let pkg = cfg.package("wireless").unwrap();
         for section in pkg.sections().unwrap() {
             let opt = section.option("channel").unwrap();
-            let updated = opt.set("foo").unwrap();
-            assert_eq!(opt.get().unwrap(), Some(updated.get().unwrap()));
+            let val_before = opt.get().unwrap();
+            opt.set("foo").unwrap();
+            let val_after = opt.get().unwrap();
+            assert_eq!(Some(Value::String("auto".into())), val_before);
+            assert_eq!(Some(Value::String("foo".into())), val_after);
         }
 
         let opt = cfg
             .package("wireless")
             .unwrap()
-            .section("wifi-device", "pdev1")
+            .section("pdev1")
             .unwrap()
             .option("channel")
             .unwrap();
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 3eb1f85..61dbf75 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,7 +1,5 @@
 use std::{
-    borrow::Cow,
     ffi::{CStr, CString},
-    iter,
     option::Option as StdOption,
 };
 
@@ -15,45 +13,27 @@ use crate::{config::handle_error, error::Error, libuci_locked, Result};
 use super::ptr::{UciPtr, PTR_STAGE_OPTION};
 
 /// represents an option within a [Section]
-// todo: get rid of const generic, use enum
-pub struct Option<const L: bool> {
-    ptr: UciPtr<PTR_STAGE_OPTION, L>,
+pub struct Option {
+    ptr: UciPtr<PTR_STAGE_OPTION>,
 }
 
-impl<const L: bool> Option<L> {
-    fn get_impl<'a>(ptr: &UciPtr<PTR_STAGE_OPTION, true>) -> Result<Value<'a>> {
-        let opt = ptr.o;
+impl Option {
+    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_OPTION>) -> Option {
+        Option { ptr }
+    }
 
-        #[allow(non_upper_case_globals)]
-        match unsafe { *opt }.type_ {
-            uci_option_type_UCI_TYPE_STRING => {
-                let raw = unsafe { CStr::from_ptr((*opt).v.string) };
-                Ok(Value::String(raw.to_str()?.into()))
-            }
-            uci_option_type_UCI_TYPE_LIST => {
-                let mut result = Vec::new();
-                unsafe {
-                    uci_foreach_element(&(*opt).v.list, |elem| {
-                        let raw = CStr::from_ptr((*elem).name);
-                        result.push(raw);
-                    })
-                };
-                Ok(Value::List(
-                    result
-                        .into_iter()
-                        .map(|cstr| cstr.to_str().map_err(Into::into).map(Into::into))
-                        .collect::<Result<Vec<_>>>()?,
-                ))
-            }
-            t => return Err(Error::Message(format!("Unexpected option type: {t}"))),
-        }
+    /// name of the option
+    pub fn name(&self) -> Result<&str> {
+        Ok(unsafe { CStr::from_ptr((*self.ptr).option) }.to_str()?)
     }
 
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
-    pub fn set(&self, value: impl AsRef<str>) -> Result<Option<true>> {
+    pub fn set(&self, value: impl AsRef<str>) -> Result<()> {
         let value = CString::new(value.as_ref())?;
+
+        // avoid modifying the long-lived uci_ptr
         let mut ptr = self.ptr.clone();
         ptr.value = value.as_ptr();
 
@@ -61,7 +41,7 @@ impl<const L: bool> Option<L> {
         let result = libuci_locked!(uci, { unsafe { uci_set(uci.ctx, &mut ptr) } });
         handle_error(&mut uci, result)?;
 
-        Ok(Option::new(self.ptr.with_update(ptr, iter::once(value))))
+        Ok(())
     }
 
     /// adds a value to the existing value
@@ -70,8 +50,10 @@ impl<const L: bool> Option<L> {
     /// - turn a single-value option into a list
     ///
     /// returns the resulting value
-    pub fn add_list<'a>(&'a self, value: impl AsRef<str>) -> Result<Option<true>> {
+    pub fn add_list<'a>(&'a self, value: impl AsRef<str>) -> Result<()> {
         let value = CString::new(value.as_ref())?;
+
+        // avoid modifying the existing uci_ptr
         let mut ptr = self.ptr.clone();
         ptr.value = value.as_ptr();
 
@@ -79,83 +61,73 @@ impl<const L: bool> Option<L> {
         let result = libuci_locked!(uci, { unsafe { uci_add_list(uci.ctx, &mut ptr) } });
         handle_error(&mut uci, result)?;
 
-        Ok(Option::new(self.ptr.with_update(ptr, iter::once(value))))
-    }
-}
-
-impl Option<false> {
-    pub(crate) fn new<const L: bool>(ptr: UciPtr<PTR_STAGE_OPTION, L>) -> Option<L> {
-        Option { ptr }
-    }
-
-    /// name of the option
-    pub fn name(&self) -> Result<&str> {
-        Ok(unsafe { CStr::from_ptr((*self.ptr).option) }.to_str()?)
+        Ok(())
     }
 
     /// returns the current value of the option, None if not set
-    pub fn get<'a>(&'a self) -> Result<StdOption<Value<'a>>> {
+    pub fn get<'a>(&'a self) -> Result<StdOption<Value>> {
         let ptr = match self.ptr.lookup()? {
             Some(ptr) => ptr,
             None => return Ok(None),
         };
-        Self::get_impl(&ptr).map(Some)
-    }
-}
 
-impl Option<true> {
-    /// name of the option
-    pub fn name(&self) -> Result<&str> {
-        self.ptr.name()
-    }
+        let opt = ptr.o;
 
-    /// returns the current value of the option, None if not set
-    pub fn get<'a>(&'a self) -> Result<Value<'a>> {
-        Self::get_impl(&self.ptr)
+        #[allow(non_upper_case_globals)]
+        match unsafe { *opt }.type_ {
+            uci_option_type_UCI_TYPE_STRING => {
+                let raw = unsafe { CStr::from_ptr((*opt).v.string) };
+                Ok(Value::String(raw.to_str()?.into()))
+            }
+            uci_option_type_UCI_TYPE_LIST => {
+                let mut result = Vec::new();
+                unsafe {
+                    uci_foreach_element(&(*opt).v.list, |elem| {
+                        let raw = CStr::from_ptr((*elem).name);
+                        result.push(raw);
+                    })
+                };
+                Ok(Value::List(
+                    result
+                        .into_iter()
+                        .map(|cstr| cstr.to_str().map_err(Into::into).map(Into::into))
+                        .collect::<Result<Vec<_>>>()?,
+                ))
+            }
+            t => return Err(Error::Message(format!("Unexpected option type: {t}"))),
+        }
+        .map(Some)
     }
 }
 
 /// represents the value of an [Option]
 #[derive(Debug)]
-pub enum Value<'a> {
-    String(Cow<'a, str>),
+pub enum Value {
+    String(String),
     Boolean(bool),
     Integer(i64),
-    List(Vec<Cow<'a, str>>),
-}
-
-impl<'a> Value<'a> {
-    pub fn to_static(self) -> Value<'static> {
-        match self {
-            Value::String(cow) => Value::String(cow.into_owned().into()),
-            Value::Boolean(v) => Value::Boolean(v),
-            Value::Integer(v) => Value::Integer(v),
-            Value::List(values) => {
-                Value::List(values.into_iter().map(|v| v.into_owned().into()).collect())
-            }
-        }
-    }
+    List(Vec<String>),
 }
 
-impl From<String> for Value<'static> {
+impl From<String> for Value {
     fn from(value: String) -> Self {
         Self::String(value.into())
     }
 }
 
-impl From<bool> for Value<'static> {
+impl From<bool> for Value {
     fn from(value: bool) -> Self {
         Self::Boolean(value)
     }
 }
 
-impl From<i64> for Value<'static> {
+impl From<i64> for Value {
     fn from(value: i64) -> Self {
         Self::Integer(value)
     }
 }
 
-impl<'a> PartialEq for Value<'a> {
+impl<'a> PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::String(l0), Self::String(r0)) => l0 == r0,
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 767485d..c109a26 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -1,7 +1,5 @@
 use std::{ffi::CStr, sync::Arc};
 
-use libuci_sys::uci_to_section;
-
 use crate::Result;
 
 use super::{
@@ -12,12 +10,12 @@ use super::{
 /// represents a single package in the config tree
 /// parent to different [Section]s
 // todo: get rid of const generic, use enum
-pub struct Package<const L: bool> {
-    ptr: UciPtr<PTR_STAGE_PACKAGE, L>,
+pub struct Package {
+    ptr: UciPtr<PTR_STAGE_PACKAGE>,
 }
 
-impl Package<false> {
-    pub(crate) fn new<const L: bool>(ptr: UciPtr<PTR_STAGE_PACKAGE, L>) -> Package<L> {
+impl Package {
+    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_PACKAGE>) -> Package {
         Package { ptr }
     }
 
@@ -25,7 +23,7 @@ impl Package<false> {
         Ok(unsafe { CStr::from_ptr(self.ptr.package) }.to_str()?)
     }
 
-    pub fn sections(&self) -> Result<impl Iterator<Item = Section<true>> + use<'_>> {
+    pub fn sections(&self) -> Result<impl Iterator<Item = Section> + use<'_>> {
         let ptr = match self.ptr.lookup()? {
             Some(ptr) => ptr,
             None => todo!(),
@@ -33,40 +31,14 @@ impl Package<false> {
         let iter = unsafe { UciListIter::new(&(*ptr.p).sections) };
         let ptr_inner = Arc::new(ptr);
         Ok(iter.map(move |elem| {
-            Section::new(ptr_inner.with_section(unsafe { uci_to_section(elem).cast_mut() }))
+            let name = unsafe { CStr::from_ptr((*elem).name) }.to_str().unwrap();
+            Section::new(ptr_inner.with_section_name(name).unwrap())
         }))
     }
-}
-
-impl Package<true> {
-    /// name of this package
-    pub fn name(&self) -> Result<&str> {
-        self.ptr.name()
-    }
 
-    /// list all [Section]s in this package
-    pub fn sections(&self) -> impl Iterator<Item = Section<true>> + use<'_> {
-        let iter = unsafe { UciListIter::new(&(*self.ptr.p).sections) };
-        iter.map(move |elem| {
-            Section::new(
-                self.ptr
-                    .with_section(unsafe { uci_to_section(elem).cast_mut() }),
-            )
-        })
-    }
-}
-
-impl<const L: bool> Package<L> {
     /// return a single [Section] by its name
     /// also works if the section is not defined yet
-    pub fn section(
-        &self,
-        _type_: impl AsRef<str>,
-        name: impl AsRef<str>,
-    ) -> Result<Section<false>> {
-        // todo: constrain lookup by section type
-        // let type_ = type_.as_ref();
-
+    pub fn section(&self, name: impl AsRef<str>) -> Result<Section> {
         let ptr = self.ptr.with_section_name(name)?;
         Ok(Section::new(ptr))
     }
diff --git a/rust-uci/src/config/ptr.rs b/rust-uci/src/config/ptr.rs
index 8e2ec92..e249ac3 100644
--- a/rust-uci/src/config/ptr.rs
+++ b/rust-uci/src/config/ptr.rs
@@ -1,5 +1,5 @@
 use std::{
-    ffi::{CStr, CString},
+    ffi::CString,
     iter::once,
     marker::PhantomData,
     ops::{Deref, DerefMut},
@@ -9,9 +9,8 @@ use std::{
 };
 
 use libuci_sys::{
-    list_to_element, uci_element, uci_list, uci_lookup_ptr, uci_option, uci_package, uci_ptr,
-    uci_ptr_UCI_LOOKUP_COMPLETE, uci_section, uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_PACKAGE,
-    uci_type_UCI_TYPE_SECTION, uci_type_UCI_TYPE_UNSPEC,
+    list_to_element, uci_element, uci_list, uci_lookup_ptr, uci_ptr, uci_type_UCI_TYPE_OPTION,
+    uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION, uci_type_UCI_TYPE_UNSPEC,
 };
 
 use crate::{config::handle_error, libuci_locked, Result, Uci};
@@ -56,13 +55,13 @@ pub(crate) const PTR_STAGE_PACKAGE: usize = 1;
 pub(crate) const PTR_STAGE_SECTION: usize = 2;
 pub(crate) const PTR_STAGE_OPTION: usize = 3;
 
-pub(crate) struct UciPtr<const S: usize, const L: bool> {
-    pub(crate) uci: Arc<Mutex<Uci>>,
+pub(crate) struct UciPtr<const S: usize> {
     ptr: uci_ptr,
-    data: Vec<Arc<CString>>,
+    pub uci: Arc<Mutex<Uci>>,
+    pub data: Vec<Arc<CString>>,
 }
 
-impl<const S: usize, const L: bool> Deref for UciPtr<S, L> {
+impl<const S: usize> Deref for UciPtr<S> {
     type Target = uci_ptr;
 
     fn deref(&self) -> &Self::Target {
@@ -70,13 +69,13 @@ impl<const S: usize, const L: bool> Deref for UciPtr<S, L> {
     }
 }
 
-impl<const S: usize, const L: bool> DerefMut for UciPtr<S, L> {
+impl<const S: usize> DerefMut for UciPtr<S> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.ptr
     }
 }
 
-impl UciPtr<PTR_STAGE_INIT, false> {
+impl UciPtr<PTR_STAGE_INIT> {
     pub fn new(uci: Arc<Mutex<Uci>>) -> Self {
         let ptr = uci_ptr {
             target: uci_type_UCI_TYPE_UNSPEC,
@@ -97,21 +96,7 @@ impl UciPtr<PTR_STAGE_INIT, false> {
         }
     }
 
-    pub fn with_package(&self, pkg: *mut uci_package) -> UciPtr<PTR_STAGE_PACKAGE, true> {
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_PACKAGE;
-        ptr.p = pkg;
-        UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: Vec::new(),
-        }
-    }
-
-    pub fn with_package_name(
-        &self,
-        name: impl AsRef<str>,
-    ) -> Result<UciPtr<PTR_STAGE_PACKAGE, false>> {
+    pub fn with_package_name(&self, name: impl AsRef<str>) -> Result<UciPtr<PTR_STAGE_PACKAGE>> {
         let name = CString::new(name.as_ref())?;
         let mut ptr = self.ptr.clone();
         ptr.target = uci_type_UCI_TYPE_PACKAGE;
@@ -124,24 +109,8 @@ impl UciPtr<PTR_STAGE_INIT, false> {
     }
 }
 
-impl UciPtr<PTR_STAGE_PACKAGE, true> {
-    pub fn with_section(&self, section: *mut uci_section) -> UciPtr<PTR_STAGE_SECTION, true> {
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_SECTION;
-        ptr.s = section;
-        UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: self.data.iter().map(Arc::clone).collect(),
-        }
-    }
-}
-
-impl<const L: bool> UciPtr<PTR_STAGE_PACKAGE, L> {
-    pub fn with_section_name(
-        &self,
-        name: impl AsRef<str>,
-    ) -> Result<UciPtr<PTR_STAGE_SECTION, false>> {
+impl UciPtr<PTR_STAGE_PACKAGE> {
+    pub fn with_section_name(&self, name: impl AsRef<str>) -> Result<UciPtr<PTR_STAGE_SECTION>> {
         let name = CString::new(name.as_ref())?;
         let mut ptr = self.ptr.clone();
         ptr.target = uci_type_UCI_TYPE_SECTION;
@@ -159,24 +128,8 @@ impl<const L: bool> UciPtr<PTR_STAGE_PACKAGE, L> {
     }
 }
 
-impl UciPtr<PTR_STAGE_SECTION, true> {
-    pub fn with_option(&self, opt: *mut uci_option) -> UciPtr<PTR_STAGE_OPTION, true> {
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_OPTION;
-        ptr.o = opt;
-        UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: self.data.iter().map(Arc::clone).collect(),
-        }
-    }
-}
-
-impl<const L: bool> UciPtr<PTR_STAGE_SECTION, L> {
-    pub fn with_option_name(
-        &self,
-        name: impl AsRef<str>,
-    ) -> Result<UciPtr<PTR_STAGE_OPTION, false>> {
+impl UciPtr<PTR_STAGE_SECTION> {
+    pub fn with_option_name(&self, name: impl AsRef<str>) -> Result<UciPtr<PTR_STAGE_OPTION>> {
         let name = CString::new(name.as_ref())?;
         let mut ptr = self.ptr.clone();
         ptr.target = uci_type_UCI_TYPE_OPTION;
@@ -194,34 +147,6 @@ impl<const L: bool> UciPtr<PTR_STAGE_SECTION, L> {
     }
 }
 
-impl<const L: bool> UciPtr<PTR_STAGE_OPTION, L> {
-    pub fn with_update(
-        &self,
-        ptr: uci_ptr,
-        extra_data: impl Iterator<Item = CString>,
-    ) -> UciPtr<PTR_STAGE_OPTION, true> {
-        if ptr.target != uci_type_UCI_TYPE_OPTION {
-            panic!("Invalid target, expected Option, got {}", ptr.target);
-        }
-        if ptr.p.is_null() || ptr.s.is_null() || ptr.o.is_null() {
-            panic!("Invalid uci_ptr: not fully looked up");
-        }
-        if ptr.flags & uci_ptr_UCI_LOOKUP_COMPLETE == 0 {
-            panic!("Invalid uci_ptr: lookup not complete");
-        }
-        UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: self
-                .data
-                .iter()
-                .map(Arc::clone)
-                .chain(extra_data.map(Arc::new))
-                .collect(),
-        }
-    }
-}
-
 struct CapturingIter<T, I> {
     inner: I,
     capture: T,
@@ -238,14 +163,8 @@ where
     }
 }
 
-impl<const S: usize> UciPtr<S, true> {
-    pub fn name(&self) -> Result<&str> {
-        Ok(unsafe { CStr::from_ptr((*self.ptr.last).name) }.to_str()?)
-    }
-}
-
-impl<const S: usize> UciPtr<S, false> {
-    pub fn lookup(&self) -> Result<StdOption<UciPtr<S, true>>> {
+impl<const S: usize> UciPtr<S> {
+    pub fn lookup(&self) -> Result<StdOption<UciPtr<S>>> {
         let mut ptr = self.ptr.clone();
         let mut uci = self.uci.lock().unwrap();
         let result = libuci_locked!(uci, {
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index f9e1caa..3f608de 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -1,8 +1,12 @@
-use std::ffi::CStr;
+use std::{
+    ffi::{CStr, CString},
+    option::Option as StdOption,
+    sync::Arc,
+};
 
-use libuci_sys::uci_to_option;
+use libuci_sys::uci_set;
 
-use crate::Result;
+use crate::{config::handle_error, libuci_locked, Result};
 
 use super::{
     option::Option,
@@ -11,44 +15,60 @@ use super::{
 
 /// represents a single section
 /// parent to different [Option]s
-// todo: get rid of const generic, use enum
-pub struct Section<const L: bool> {
-    ptr: UciPtr<PTR_STAGE_SECTION, L>,
+pub struct Section {
+    ptr: UciPtr<PTR_STAGE_SECTION>,
 }
 
-impl<const L: bool> Section<L> {
-    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_SECTION, L>) -> Self {
+impl Section {
+    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_SECTION>) -> Self {
         Self { ptr }
     }
-}
 
-impl Section<true> {
-    /// returns the name of named sections, otherwise None
+    pub fn create(&self, type_: impl AsRef<str>) -> Result<()> {
+        let type_ = CString::new(type_.as_ref())?;
+
+        // avoid modifying the long-lived uci_ptr
+        let mut ptr = self.ptr.clone();
+        ptr.value = type_.as_ptr();
+
+        let uci = Arc::clone(&self.ptr.uci);
+        let mut uci = uci.lock().unwrap();
+        let result = libuci_locked!(uci, unsafe { uci_set(uci.ctx, &mut ptr) });
+        handle_error(&mut uci, result)?;
+
+        Ok(())
+    }
+
+    /// returns the name of the section item
     pub fn name(&self) -> Result<&str> {
-        self.ptr.name()
+        Ok(unsafe { CStr::from_ptr(self.ptr.section) }.to_str()?)
     }
 
-    /// returns the type of the section
-    pub fn type_(&mut self) -> Result<&str> {
-        Ok(unsafe { CStr::from_ptr((*self.ptr.s).type_) }.to_str()?)
+    /// returns the type of the section, if it exists
+    pub fn type_(&self) -> Result<StdOption<String>> {
+        let ptr = match self.ptr.lookup()? {
+            Some(ptr) => ptr,
+            None => return Ok(None),
+        };
+        Ok(Some(
+            unsafe { CStr::from_ptr((*ptr.s).type_) }
+                .to_str()?
+                .to_owned(),
+        ))
     }
 
     /// lists all options in this section
-    pub fn options(&self) -> impl Iterator<Item = Option<true>> + use<'_> {
+    pub fn options(&self) -> impl Iterator<Item = Option> + use<'_> {
         let iter = unsafe { UciListIter::new(&(*self.ptr.s).options) };
         iter.map(move |elem| {
-            Option::new(
-                self.ptr
-                    .with_option(unsafe { uci_to_option(elem).cast_mut() }),
-            )
+            let name = unsafe { CStr::from_ptr((*elem).name) }.to_str().unwrap();
+            Option::new(self.ptr.with_option_name(name).unwrap())
         })
     }
-}
 
-impl<const L: bool> Section<L> {
     /// returns a specific [Option] by name
     /// also works if the option is not defined yet
-    pub fn option(&self, name: impl AsRef<str>) -> Result<Option<false>> {
+    pub fn option(&self, name: impl AsRef<str>) -> Result<Option> {
         let ptr = self.ptr.with_option_name(name)?;
         Ok(Option::new(ptr))
     }

From e44a8c32dce688f2b88b14c0b881dfe860d6779b Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 03:24:46 +0200
Subject: [PATCH 06/24] Fix section creation

---
 rust-uci/src/config/mod.rs     |  4 +-
 rust-uci/src/config/option.rs  | 21 +++++++--
 rust-uci/src/config/package.rs | 13 ++++--
 rust-uci/src/config/ptr.rs     | 82 +++++++++++++++++++++++++++-------
 rust-uci/src/config/section.rs | 35 ++++++++++++---
 5 files changed, 125 insertions(+), 30 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index d39620b..5811c9d 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -140,7 +140,7 @@ mod tests {
 
         let cfg: Config = uci.into();
         let pkg = cfg.package("wireless").unwrap();
-        let sect = pkg.section("pdev0").unwrap();
+        let sect = pkg.section("wifi-device", "pdev0").unwrap();
         let opt = sect.option("channel").unwrap();
         let val = opt.get().unwrap();
         assert_eq!(Some(option::Value::String("auto".into())), val);
@@ -204,7 +204,7 @@ mod tests {
         let opt = cfg
             .package("wireless")
             .unwrap()
-            .section("pdev1")
+            .section("wifi-device", "pdev1")
             .unwrap()
             .option("channel")
             .unwrap();
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 61dbf75..dea7f54 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,6 +1,8 @@
 use std::{
     ffi::{CStr, CString},
     option::Option as StdOption,
+    ptr,
+    sync::Arc,
 };
 
 use libuci_sys::{
@@ -10,16 +12,20 @@ use libuci_sys::{
 
 use crate::{config::handle_error, error::Error, libuci_locked, Result};
 
-use super::ptr::{UciPtr, PTR_STAGE_OPTION};
+use super::{
+    ptr::{UciPtr, PTR_STAGE_OPTION},
+    section::Section,
+};
 
 /// represents an option within a [Section]
 pub struct Option {
     ptr: UciPtr<PTR_STAGE_OPTION>,
+    section_type: Arc<str>,
 }
 
 impl Option {
-    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_OPTION>) -> Option {
-        Option { ptr }
+    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_OPTION>, section_type: Arc<str>) -> Option {
+        Option { ptr, section_type }
     }
 
     /// name of the option
@@ -27,14 +33,23 @@ impl Option {
         Ok(unsafe { CStr::from_ptr((*self.ptr).option) }.to_str()?)
     }
 
+    pub fn section(&self) -> Section {
+        let ptr = self.ptr.parent();
+        Section::new(ptr, Arc::clone(&self.section_type))
+    }
+
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
     pub fn set(&self, value: impl AsRef<str>) -> Result<()> {
         let value = CString::new(value.as_ref())?;
 
+        let section = self.section().ensure()?;
+
         // avoid modifying the long-lived uci_ptr
         let mut ptr = self.ptr.clone();
+        ptr.s = section.s;
+        ptr.section = ptr::null();
         ptr.value = value.as_ptr();
 
         let mut uci = self.ptr.uci.lock().unwrap();
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index c109a26..b435e7f 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -1,5 +1,7 @@
 use std::{ffi::CStr, sync::Arc};
 
+use libuci_sys::uci_to_section;
+
 use crate::Result;
 
 use super::{
@@ -32,14 +34,19 @@ impl Package {
         let ptr_inner = Arc::new(ptr);
         Ok(iter.map(move |elem| {
             let name = unsafe { CStr::from_ptr((*elem).name) }.to_str().unwrap();
-            Section::new(ptr_inner.with_section_name(name).unwrap())
+            let sect = unsafe { uci_to_section(elem) };
+            let type_ = unsafe { CStr::from_ptr((*sect).type_) }
+                .to_str()
+                .unwrap()
+                .into();
+            Section::new(ptr_inner.with_section_name(name).unwrap(), type_)
         }))
     }
 
     /// return a single [Section] by its name
     /// also works if the section is not defined yet
-    pub fn section(&self, name: impl AsRef<str>) -> Result<Section> {
+    pub fn section(&self, type_: impl AsRef<str>, name: impl AsRef<str>) -> Result<Section> {
         let ptr = self.ptr.with_section_name(name)?;
-        Ok(Section::new(ptr))
+        Ok(Section::new(ptr, type_.as_ref().into()))
     }
 }
diff --git a/rust-uci/src/config/ptr.rs b/rust-uci/src/config/ptr.rs
index e249ac3..58ee9d9 100644
--- a/rust-uci/src/config/ptr.rs
+++ b/rust-uci/src/config/ptr.rs
@@ -9,11 +9,12 @@ use std::{
 };
 
 use libuci_sys::{
-    list_to_element, uci_element, uci_list, uci_lookup_ptr, uci_ptr, uci_type_UCI_TYPE_OPTION,
-    uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION, uci_type_UCI_TYPE_UNSPEC,
+    list_to_element, uci_element, uci_list, uci_lookup_ptr, uci_ptr, uci_ptr_UCI_LOOKUP_COMPLETE,
+    uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION,
+    uci_type_UCI_TYPE_UNSPEC,
 };
 
-use crate::{config::handle_error, libuci_locked, Result, Uci};
+use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
 
 pub(super) struct UciListIter<'a> {
     list: *const uci_list,
@@ -145,21 +146,41 @@ impl UciPtr<PTR_STAGE_SECTION> {
                 .collect(),
         })
     }
-}
 
-struct CapturingIter<T, I> {
-    inner: I,
-    capture: T,
+    pub fn parent(&self) -> UciPtr<PTR_STAGE_PACKAGE> {
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_PACKAGE;
+        let section_ptr = ptr.section;
+        ptr.section = ptr::null();
+        UciPtr {
+            ptr,
+            uci: Arc::clone(&self.uci),
+            data: self
+                .data
+                .iter()
+                .filter(|v| v.as_ptr() != section_ptr)
+                .map(Arc::clone)
+                .collect(),
+        }
+    }
 }
 
-impl<T, I> Iterator for CapturingIter<T, I>
-where
-    I: Iterator,
-{
-    type Item = I::Item;
-
-    fn next(&mut self) -> StdOption<Self::Item> {
-        self.inner.next()
+impl UciPtr<PTR_STAGE_OPTION> {
+    pub fn parent(&self) -> UciPtr<PTR_STAGE_SECTION> {
+        let mut ptr = self.ptr.clone();
+        ptr.target = uci_type_UCI_TYPE_SECTION;
+        let option_ptr = ptr.option;
+        ptr.option = ptr::null();
+        UciPtr {
+            ptr,
+            uci: Arc::clone(&self.uci),
+            data: self
+                .data
+                .iter()
+                .filter(|v| v.as_ptr() != option_ptr)
+                .map(Arc::clone)
+                .collect(),
+        }
     }
 }
 
@@ -170,12 +191,41 @@ impl<const S: usize> UciPtr<S> {
         let result = libuci_locked!(uci, {
             unsafe { uci_lookup_ptr(uci.ctx, &mut ptr, ptr::null_mut(), true) }
         });
-        Ok(handle_error(&mut uci, result)?.map(|_| UciPtr {
+        let ptr = match handle_error(&mut uci, result)? {
+            Some(_) => {
+                if ptr.flags & uci_ptr_UCI_LOOKUP_COMPLETE == 0 {
+                    return Ok(None);
+                }
+                ptr
+            }
+            None => return Ok(None),
+        };
+        Ok(Some(UciPtr {
             uci: Arc::clone(&self.uci),
             ptr,
             data: self.data.iter().map(Arc::clone).collect(),
         }))
     }
+
+    pub fn replace(
+        &self,
+        ptr: uci_ptr,
+        extra_data: impl Iterator<Item = CString>,
+    ) -> Result<UciPtr<S>> {
+        if self.ptr.target != ptr.target {
+            return Err(Error::Message("Invalid target provided".into()));
+        }
+        Ok(UciPtr {
+            ptr,
+            uci: Arc::clone(&self.uci),
+            data: self
+                .data
+                .iter()
+                .map(Arc::clone)
+                .chain(extra_data.map(Arc::new))
+                .collect(),
+        })
+    }
 }
 
 #[cfg(test)]
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 3f608de..3134081 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -1,5 +1,6 @@
 use std::{
     ffi::{CStr, CString},
+    iter,
     option::Option as StdOption,
     sync::Arc,
 };
@@ -10,22 +11,24 @@ use crate::{config::handle_error, libuci_locked, Result};
 
 use super::{
     option::Option,
+    package::Package,
     ptr::{UciListIter, UciPtr, PTR_STAGE_SECTION},
 };
 
 /// represents a single section
 /// parent to different [Option]s
 pub struct Section {
+    type_: Arc<str>,
     ptr: UciPtr<PTR_STAGE_SECTION>,
 }
 
 impl Section {
-    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_SECTION>) -> Self {
-        Self { ptr }
+    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_SECTION>, type_: Arc<str>) -> Self {
+        Self { ptr, type_ }
     }
 
-    pub fn create(&self, type_: impl AsRef<str>) -> Result<()> {
-        let type_ = CString::new(type_.as_ref())?;
+    fn create_impl(&self) -> Result<UciPtr<PTR_STAGE_SECTION>> {
+        let type_ = CString::new(self.type_.as_bytes())?;
 
         // avoid modifying the long-lived uci_ptr
         let mut ptr = self.ptr.clone();
@@ -36,9 +39,21 @@ impl Section {
         let result = libuci_locked!(uci, unsafe { uci_set(uci.ctx, &mut ptr) });
         handle_error(&mut uci, result)?;
 
+        self.ptr.replace(ptr, iter::once(type_))
+    }
+
+    pub fn create(&self) -> Result<()> {
+        self.create_impl()?;
         Ok(())
     }
 
+    pub(crate) fn ensure(&self) -> Result<UciPtr<PTR_STAGE_SECTION>> {
+        match self.ptr.lookup()? {
+            Some(ptr) => return Ok(ptr),
+            None => self.create_impl(),
+        }
+    }
+
     /// returns the name of the section item
     pub fn name(&self) -> Result<&str> {
         Ok(unsafe { CStr::from_ptr(self.ptr.section) }.to_str()?)
@@ -62,7 +77,10 @@ impl Section {
         let iter = unsafe { UciListIter::new(&(*self.ptr.s).options) };
         iter.map(move |elem| {
             let name = unsafe { CStr::from_ptr((*elem).name) }.to_str().unwrap();
-            Option::new(self.ptr.with_option_name(name).unwrap())
+            Option::new(
+                self.ptr.with_option_name(name).unwrap(),
+                Arc::clone(&self.type_),
+            )
         })
     }
 
@@ -70,6 +88,11 @@ impl Section {
     /// also works if the option is not defined yet
     pub fn option(&self, name: impl AsRef<str>) -> Result<Option> {
         let ptr = self.ptr.with_option_name(name)?;
-        Ok(Option::new(ptr))
+        Ok(Option::new(ptr, Arc::clone(&self.type_)))
+    }
+
+    pub fn package(&self) -> Package {
+        let ptr = self.ptr.parent();
+        Package::new(ptr)
     }
 }

From a2e11e453c8c289ca71894fdb616487df14ff7c3 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 17:18:27 +0200
Subject: [PATCH 07/24] Refactor to avoid dangling pointers

---
 libuci-sys/src/lib.rs          |   9 +-
 rust-uci/src/config/mod.rs     |  38 +++---
 rust-uci/src/config/option.rs  | 101 +++++++++++-----
 rust-uci/src/config/package.rs |  98 ++++++++++++----
 rust-uci/src/config/ptr.rs     | 182 ++++++-----------------------
 rust-uci/src/config/section.rs | 206 +++++++++++++++++++++++++--------
 6 files changed, 359 insertions(+), 275 deletions(-)

diff --git a/libuci-sys/src/lib.rs b/libuci-sys/src/lib.rs
index a572955..1a91eb8 100644
--- a/libuci-sys/src/lib.rs
+++ b/libuci-sys/src/lib.rs
@@ -33,10 +33,11 @@ pub use bindings::{
     uci_list_configs, uci_load, uci_lookup_next, uci_lookup_ptr, uci_option, uci_option_type,
     uci_option_type_UCI_TYPE_LIST, uci_option_type_UCI_TYPE_STRING, uci_package,
     uci_parse_argument, uci_parse_context, uci_parse_option, uci_parse_ptr, uci_parse_section,
-    uci_perror, uci_ptr, uci_ptr_UCI_LOOKUP_COMPLETE, uci_rename, uci_reorder_section, uci_revert,
-    uci_save, uci_section, uci_set, uci_set_backend, uci_set_confdir, uci_set_savedir, uci_type,
-    uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION,
-    uci_type_UCI_TYPE_UNSPEC, uci_unload, uci_validate_text, UCI_ERR_NOTFOUND, UCI_OK,
+    uci_perror, uci_ptr, uci_ptr_UCI_LOOKUP_COMPLETE, uci_ptr_UCI_LOOKUP_EXTENDED, uci_rename,
+    uci_reorder_section, uci_revert, uci_save, uci_section, uci_set, uci_set_backend,
+    uci_set_confdir, uci_set_savedir, uci_type, uci_type_UCI_TYPE_OPTION,
+    uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION, uci_type_UCI_TYPE_UNSPEC, uci_unload,
+    uci_validate_text, UCI_ERR_NOTFOUND, UCI_OK,
 };
 
 #[allow(clippy::ptr_offset_with_cast)]
diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 5811c9d..420ff6f 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -1,5 +1,5 @@
 use std::{
-    ffi::{c_char, CStr},
+    ffi::{c_char, CStr, CString},
     option::Option as StdOption,
     sync::{Arc, Mutex},
 };
@@ -17,7 +17,6 @@ mod package;
 use package::Package;
 
 mod ptr;
-use ptr::UciPtr;
 
 mod section;
 
@@ -52,9 +51,8 @@ impl Iterator for PackageIter {
             return None;
         }
         self.ptr = unsafe { self.ptr.add(1) };
-        let name = unsafe { CStr::from_ptr(name_ptr.cast()) }.to_str().unwrap();
-        let ptr = UciPtr::new(Arc::clone(&self.uci));
-        Some(Package::new(ptr.with_package_name(name).unwrap()))
+        let name = unsafe { CStr::from_ptr(name_ptr.cast()) }.to_owned();
+        Some(Package::new(Arc::clone(&self.uci), Arc::new(name)))
     }
 }
 
@@ -65,10 +63,11 @@ impl Config {
 
     /// return a single [Package] by its name
     /// also works if the package is not defined yet
-    pub fn package<'a>(&self, name: impl AsRef<str>) -> Result<Package> {
-        let ptr = ptr::UciPtr::new(Arc::clone(&self.uci));
-        let ptr = ptr.with_package_name(name)?;
-        Ok(Package::new(ptr))
+    pub fn package<'a>(&self, name: impl AsRef<str>) -> Result<StdOption<Package>> {
+        let cname = CString::new(name.as_ref())?;
+        let pkg = Package::new(Arc::clone(&self.uci), Arc::new(cname));
+        let mut uci = self.uci.lock().unwrap();
+        Ok(pkg.ptr(&mut uci)?.map(|_| pkg))
     }
 
     /// list all [Package]s in the config
@@ -106,7 +105,7 @@ fn handle_error(uci: &mut Uci, result: i32) -> Result<Option<()>> {
 mod tests {
     use tempfile::{tempdir, TempDir};
 
-    use super::{option::Value, *};
+    use super::{option::Value, section::SectionIdent, *};
 
     fn setup_uci() -> Result<(Uci, TempDir)> {
         let mut uci = Uci::new()?;
@@ -139,8 +138,10 @@ mod tests {
         .unwrap();
 
         let cfg: Config = uci.into();
-        let pkg = cfg.package("wireless").unwrap();
-        let sect = pkg.section("wifi-device", "pdev0").unwrap();
+        let pkg = cfg.package("wireless").unwrap().unwrap();
+        let sect = pkg
+            .section("wifi-device", SectionIdent::Named("pdev0"))
+            .unwrap();
         let opt = sect.option("channel").unwrap();
         let val = opt.get().unwrap();
         assert_eq!(Some(option::Value::String("auto".into())), val);
@@ -191,9 +192,9 @@ mod tests {
         .unwrap();
 
         let cfg: Config = uci.into();
-        let pkg = cfg.package("wireless").unwrap();
+        let pkg = cfg.package("wireless").unwrap().unwrap();
         for section in pkg.sections().unwrap() {
-            let opt = section.option("channel").unwrap();
+            let mut opt = section.option("channel").unwrap();
             let val_before = opt.get().unwrap();
             opt.set("foo").unwrap();
             let val_after = opt.get().unwrap();
@@ -201,15 +202,16 @@ mod tests {
             assert_eq!(Some(Value::String("foo".into())), val_after);
         }
 
-        let opt = cfg
+        let mut opt = cfg
             .package("wireless")
             .unwrap()
-            .section("wifi-device", "pdev1")
+            .unwrap()
+            .section("wifi-device", SectionIdent::Named("pdev1"))
             .unwrap()
             .option("channel")
             .unwrap();
-        let updated1 = opt.set("foo").unwrap();
-        let updated2 = opt.set("auto").unwrap();
+        opt.set("foo").unwrap();
+        opt.set("auto").unwrap();
         println!("done!");
     }
 }
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index dea7f54..74fb3d5 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,59 +1,101 @@
 use std::{
     ffi::{CStr, CString},
+    ops::DerefMut,
     option::Option as StdOption,
-    ptr,
-    sync::Arc,
+    sync::{Arc, Mutex},
 };
 
 use libuci_sys::{
     uci_add_list, uci_foreach_element, uci_option_type_UCI_TYPE_LIST,
-    uci_option_type_UCI_TYPE_STRING, uci_set,
+    uci_option_type_UCI_TYPE_STRING, uci_set, uci_type_UCI_TYPE_OPTION,
 };
 
-use crate::{config::handle_error, error::Error, libuci_locked, Result};
+use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
 
 use super::{
-    ptr::{UciPtr, PTR_STAGE_OPTION},
-    section::Section,
+    ptr::UciPtr,
+    section::{Section, SectionIdent},
 };
 
 /// represents an option within a [Section]
 pub struct Option {
-    ptr: UciPtr<PTR_STAGE_OPTION>,
-    section_type: Arc<str>,
+    uci: Arc<Mutex<Uci>>,
+    package: Arc<CString>,
+    section: (Arc<CString>, Arc<SectionIdent<CString>>),
+    name: Arc<CString>,
 }
 
 impl Option {
-    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_OPTION>, section_type: Arc<str>) -> Option {
-        Option { ptr, section_type }
+    pub(crate) fn new(
+        uci: Arc<Mutex<Uci>>,
+        package: Arc<CString>,
+        section: (Arc<CString>, Arc<SectionIdent<CString>>),
+        name: Arc<CString>,
+    ) -> Option {
+        Option {
+            uci,
+            package,
+            section,
+            name,
+        }
+    }
+
+    fn ptr<'a>(&'_ self, uci: &'a mut Uci) -> Result<StdOption<UciPtr<'a>>> {
+        let section = match self.section().ptr(uci)? {
+            Some(s) => s,
+            None => return Ok(None),
+        };
+
+        let mut ptr = UciPtr::new();
+        ptr.target = uci_type_UCI_TYPE_OPTION;
+        ptr.p = section.p;
+        ptr.s = section.s;
+        ptr.option = self.name.as_ptr();
+        ptr.lookup(uci)
+    }
+
+    fn ptr_ensure<'a>(&'a mut self) -> Result<UciPtr<'a>> {
+        let mut uci = self.uci.lock().unwrap();
+        let mut section = self.section();
+        let section_ptr = section.ensure(Some(&mut uci))?;
+
+        // update ident to match newly created item
+        self.section.1 = Arc::clone(&section.ident);
+
+        let mut ptr = UciPtr::new();
+        ptr.target = uci_type_UCI_TYPE_OPTION;
+        ptr.p = section_ptr.p;
+        ptr.s = section_ptr.s;
+        ptr.option = self.name.as_ptr();
+        Ok(ptr)
     }
 
     /// name of the option
-    pub fn name(&self) -> Result<&str> {
-        Ok(unsafe { CStr::from_ptr((*self.ptr).option) }.to_str()?)
+    pub fn name(&self) -> &str {
+        self.name.to_str().unwrap()
     }
 
     pub fn section(&self) -> Section {
-        let ptr = self.ptr.parent();
-        Section::new(ptr, Arc::clone(&self.section_type))
+        Section::new(
+            Arc::clone(&self.uci),
+            Arc::clone(&self.package),
+            Arc::clone(&self.section.0),
+            Arc::clone(&self.section.1),
+        )
     }
 
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
-    pub fn set(&self, value: impl AsRef<str>) -> Result<()> {
+    pub fn set(&mut self, value: impl AsRef<str>) -> Result<()> {
         let value = CString::new(value.as_ref())?;
 
-        let section = self.section().ensure()?;
-
-        // avoid modifying the long-lived uci_ptr
-        let mut ptr = self.ptr.clone();
-        ptr.s = section.s;
-        ptr.section = ptr::null();
+        let mut ptr = self.ptr_ensure()?;
         ptr.value = value.as_ptr();
+        let ptr = ptr.deref_mut() as *mut _;
 
-        let mut uci = self.ptr.uci.lock().unwrap();
-        let result = libuci_locked!(uci, { unsafe { uci_set(uci.ctx, &mut ptr) } });
+        let mut uci = self.uci.lock().unwrap();
+        let result = libuci_locked!(uci, { unsafe { uci_set(uci.ctx, ptr) } });
         handle_error(&mut uci, result)?;
 
         Ok(())
@@ -65,15 +107,15 @@ impl Option {
     /// - turn a single-value option into a list
     ///
     /// returns the resulting value
-    pub fn add_list<'a>(&'a self, value: impl AsRef<str>) -> Result<()> {
+    pub fn add_list(&mut self, value: impl AsRef<str>) -> Result<()> {
         let value = CString::new(value.as_ref())?;
 
-        // avoid modifying the existing uci_ptr
-        let mut ptr = self.ptr.clone();
+        let mut ptr = self.ptr_ensure()?;
         ptr.value = value.as_ptr();
+        let ptr = ptr.deref_mut() as *mut _;
 
-        let mut uci = self.ptr.uci.lock().unwrap();
-        let result = libuci_locked!(uci, { unsafe { uci_add_list(uci.ctx, &mut ptr) } });
+        let mut uci = self.uci.lock().unwrap();
+        let result = libuci_locked!(uci, { unsafe { uci_add_list(uci.ctx, ptr) } });
         handle_error(&mut uci, result)?;
 
         Ok(())
@@ -81,7 +123,8 @@ impl Option {
 
     /// returns the current value of the option, None if not set
     pub fn get<'a>(&'a self) -> Result<StdOption<Value>> {
-        let ptr = match self.ptr.lookup()? {
+        let mut uci = self.uci.lock().unwrap();
+        let ptr = match self.ptr(&mut uci)? {
             Some(ptr) => ptr,
             None => return Ok(None),
         };
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index b435e7f..edf8537 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -1,52 +1,100 @@
-use std::{ffi::CStr, sync::Arc};
+use std::{
+    ffi::{CStr, CString},
+    option::Option as StdOption,
+    ptr,
+    sync::{Arc, Mutex},
+};
 
-use libuci_sys::uci_to_section;
+use libuci_sys::{uci_section, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
 
-use crate::Result;
+use crate::{config::section::SectionIdent, Result, Uci};
 
 use super::{
-    ptr::{UciListIter, UciPtr, PTR_STAGE_PACKAGE},
+    ptr::{UciListIter, UciPtr},
     section::Section,
 };
 
 /// represents a single package in the config tree
 /// parent to different [Section]s
-// todo: get rid of const generic, use enum
 pub struct Package {
-    ptr: UciPtr<PTR_STAGE_PACKAGE>,
+    uci: Arc<Mutex<Uci>>,
+    name: Arc<CString>,
 }
 
 impl Package {
-    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_PACKAGE>) -> Package {
-        Package { ptr }
+    pub(crate) fn new(uci: Arc<Mutex<Uci>>, name: Arc<CString>) -> Package {
+        Package { uci, name }
     }
 
     pub fn name(&self) -> Result<&str> {
-        Ok(unsafe { CStr::from_ptr(self.ptr.package) }.to_str()?)
+        Ok(self.name.to_str()?)
+    }
+
+    pub(crate) fn ptr<'a>(&'_ self, uci: &'a mut Uci) -> Result<StdOption<UciPtr<'a>>> {
+        let mut ptr = UciPtr::new();
+        ptr.target = uci_type_UCI_TYPE_PACKAGE;
+        ptr.package = self.name.as_c_str().as_ptr();
+        ptr.lookup(uci)
+    }
+
+    pub(crate) unsafe fn section_ident(section: *const uci_section) -> SectionIdent<CString> {
+        let elem = &unsafe { *section }.e;
+        match unsafe { *section }.anonymous {
+            true => UciListIter::new(&unsafe { *(*section).package }.sections)
+                .enumerate()
+                .find(|(_, sect_elem)| *sect_elem == elem)
+                .map(|(i, _)| SectionIdent::Indexed(i as i32))
+                .unwrap_or(SectionIdent::Anonymous),
+            false => {
+                let name = unsafe { CStr::from_ptr((*elem).name) }.to_owned();
+                SectionIdent::Named(name)
+            }
+        }
     }
 
-    pub fn sections(&self) -> Result<impl Iterator<Item = Section> + use<'_>> {
-        let ptr = match self.ptr.lookup()? {
-            Some(ptr) => ptr,
-            None => todo!(),
+    pub fn sections(&self) -> Result<impl Iterator<Item = Section>> {
+        let mut uci = self.uci.lock().unwrap();
+        let ptr = match self.ptr(&mut uci)? {
+            Some(ptr) => unsafe { &(*ptr.p).sections },
+            None => ptr::null(),
         };
-        let iter = unsafe { UciListIter::new(&(*ptr.p).sections) };
-        let ptr_inner = Arc::new(ptr);
-        Ok(iter.map(move |elem| {
-            let name = unsafe { CStr::from_ptr((*elem).name) }.to_str().unwrap();
+        drop(uci);
+        let uci = Arc::clone(&self.uci);
+        let package = Arc::clone(&self.name);
+        Ok(UciListIter::new(ptr).map(move |elem| {
             let sect = unsafe { uci_to_section(elem) };
-            let type_ = unsafe { CStr::from_ptr((*sect).type_) }
-                .to_str()
-                .unwrap()
-                .into();
-            Section::new(ptr_inner.with_section_name(name).unwrap(), type_)
+            let type_ = unsafe { CStr::from_ptr((*sect).type_) }.to_owned();
+            let ident = unsafe { Self::section_ident(sect) };
+            Section::new(
+                Arc::clone(&uci),
+                Arc::clone(&package),
+                Arc::new(type_),
+                Arc::new(ident),
+            )
         }))
     }
 
     /// return a single [Section] by its name
     /// also works if the section is not defined yet
-    pub fn section(&self, type_: impl AsRef<str>, name: impl AsRef<str>) -> Result<Section> {
-        let ptr = self.ptr.with_section_name(name)?;
-        Ok(Section::new(ptr, type_.as_ref().into()))
+    pub fn section(
+        &self,
+        type_: impl AsRef<str>,
+        ident: SectionIdent<impl AsRef<str>>,
+    ) -> Result<Section> {
+        let type_ = CString::new(type_.as_ref())?;
+
+        use SectionIdent::*;
+        let ident = match ident {
+            Anonymous => Anonymous,
+            Indexed(i) => Indexed(i),
+            Named(n) => Named(CString::new(n.as_ref())?),
+        };
+
+        Ok(Section::new(
+            Arc::clone(&self.uci),
+            Arc::clone(&self.name),
+            Arc::new(type_),
+            Arc::new(ident),
+        ))
     }
 }
diff --git a/rust-uci/src/config/ptr.rs b/rust-uci/src/config/ptr.rs
index 58ee9d9..7f7b349 100644
--- a/rust-uci/src/config/ptr.rs
+++ b/rust-uci/src/config/ptr.rs
@@ -1,33 +1,42 @@
 use std::{
-    ffi::CString,
-    iter::once,
     marker::PhantomData,
     ops::{Deref, DerefMut},
     option::Option as StdOption,
     ptr,
-    sync::{Arc, Mutex},
 };
 
 use libuci_sys::{
     list_to_element, uci_element, uci_list, uci_lookup_ptr, uci_ptr, uci_ptr_UCI_LOOKUP_COMPLETE,
-    uci_type_UCI_TYPE_OPTION, uci_type_UCI_TYPE_PACKAGE, uci_type_UCI_TYPE_SECTION,
     uci_type_UCI_TYPE_UNSPEC,
 };
 
-use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
+use crate::{config::handle_error, libuci_locked, Result, Uci};
 
+/// mimicks the `uci_foreach_element_safe` macro in libuci
+/// supposedly deletion safe
 pub(super) struct UciListIter<'a> {
-    list: *const uci_list,
-    ptr: *const uci_list,
+    list: *const uci_list,   // head of the list, doesn't change
+    ptr: *const uci_element, // next element
+    tmp: *const uci_element, // element after ptr
     _lt: &'a PhantomData<()>,
 }
 
 impl<'a> UciListIter<'a> {
-    /// Safety: list cannot be null
-    pub unsafe fn new(list: *const uci_list) -> Self {
+    pub fn new(list: *const uci_list) -> Self {
+        let ptr = if list.is_null() {
+            ptr::null()
+        } else {
+            unsafe { list_to_element((*list).next) }
+        };
+        let tmp = if ptr.is_null() {
+            ptr::null()
+        } else {
+            unsafe { list_to_element((*ptr).list.next) }
+        };
         Self {
             list,
-            ptr: unsafe { *list }.next,
+            ptr,
+            tmp,
             _lt: &PhantomData,
         }
     }
@@ -40,29 +49,25 @@ impl<'a> Iterator for UciListIter<'a> {
         if self.ptr.is_null() {
             return None;
         }
-        if self.ptr == self.list {
+        if unsafe { &raw const (*self.ptr).list } == self.list {
             return None;
         }
 
-        let elem = unsafe { list_to_element(self.ptr) };
-        self.ptr = unsafe { *elem }.list.next;
+        let elem = self.ptr;
+
+        self.ptr = self.tmp;
+        self.tmp = unsafe { list_to_element((*self.ptr).list.next) };
 
         Some(elem)
     }
 }
 
-pub(crate) const PTR_STAGE_INIT: usize = 0;
-pub(crate) const PTR_STAGE_PACKAGE: usize = 1;
-pub(crate) const PTR_STAGE_SECTION: usize = 2;
-pub(crate) const PTR_STAGE_OPTION: usize = 3;
-
-pub(crate) struct UciPtr<const S: usize> {
+pub(crate) struct UciPtr<'a> {
     ptr: uci_ptr,
-    pub uci: Arc<Mutex<Uci>>,
-    pub data: Vec<Arc<CString>>,
+    _lt: &'a PhantomData<()>,
 }
 
-impl<const S: usize> Deref for UciPtr<S> {
+impl Deref for UciPtr<'_> {
     type Target = uci_ptr;
 
     fn deref(&self) -> &Self::Target {
@@ -70,14 +75,14 @@ impl<const S: usize> Deref for UciPtr<S> {
     }
 }
 
-impl<const S: usize> DerefMut for UciPtr<S> {
+impl DerefMut for UciPtr<'_> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         &mut self.ptr
     }
 }
 
-impl UciPtr<PTR_STAGE_INIT> {
-    pub fn new(uci: Arc<Mutex<Uci>>) -> Self {
+impl<'a> UciPtr<'a> {
+    pub fn new() -> UciPtr<'static> {
         let ptr = uci_ptr {
             target: uci_type_UCI_TYPE_UNSPEC,
             flags: 0,
@@ -90,108 +95,18 @@ impl UciPtr<PTR_STAGE_INIT> {
             option: ptr::null(),
             value: ptr::null(),
         };
-        Self {
-            uci,
-            ptr,
-            data: Vec::new(),
-        }
-    }
-
-    pub fn with_package_name(&self, name: impl AsRef<str>) -> Result<UciPtr<PTR_STAGE_PACKAGE>> {
-        let name = CString::new(name.as_ref())?;
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_PACKAGE;
-        ptr.package = name.as_ptr();
-        Ok(UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: vec![Arc::new(name)],
-        })
-    }
-}
-
-impl UciPtr<PTR_STAGE_PACKAGE> {
-    pub fn with_section_name(&self, name: impl AsRef<str>) -> Result<UciPtr<PTR_STAGE_SECTION>> {
-        let name = CString::new(name.as_ref())?;
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_SECTION;
-        ptr.section = name.as_ptr();
-        Ok(UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: self
-                .data
-                .iter()
-                .map(Arc::clone)
-                .chain(once(Arc::new(name)))
-                .collect(),
-        })
-    }
-}
-
-impl UciPtr<PTR_STAGE_SECTION> {
-    pub fn with_option_name(&self, name: impl AsRef<str>) -> Result<UciPtr<PTR_STAGE_OPTION>> {
-        let name = CString::new(name.as_ref())?;
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_OPTION;
-        ptr.option = name.as_ptr();
-        Ok(UciPtr {
-            uci: Arc::clone(&self.uci),
-            ptr,
-            data: self
-                .data
-                .iter()
-                .map(Arc::clone)
-                .chain(once(Arc::new(name)))
-                .collect(),
-        })
-    }
-
-    pub fn parent(&self) -> UciPtr<PTR_STAGE_PACKAGE> {
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_PACKAGE;
-        let section_ptr = ptr.section;
-        ptr.section = ptr::null();
-        UciPtr {
-            ptr,
-            uci: Arc::clone(&self.uci),
-            data: self
-                .data
-                .iter()
-                .filter(|v| v.as_ptr() != section_ptr)
-                .map(Arc::clone)
-                .collect(),
-        }
-    }
-}
-
-impl UciPtr<PTR_STAGE_OPTION> {
-    pub fn parent(&self) -> UciPtr<PTR_STAGE_SECTION> {
-        let mut ptr = self.ptr.clone();
-        ptr.target = uci_type_UCI_TYPE_SECTION;
-        let option_ptr = ptr.option;
-        ptr.option = ptr::null();
         UciPtr {
             ptr,
-            uci: Arc::clone(&self.uci),
-            data: self
-                .data
-                .iter()
-                .filter(|v| v.as_ptr() != option_ptr)
-                .map(Arc::clone)
-                .collect(),
+            _lt: &PhantomData,
         }
     }
-}
 
-impl<const S: usize> UciPtr<S> {
-    pub fn lookup(&self) -> Result<StdOption<UciPtr<S>>> {
+    pub fn lookup<'b>(&'_ mut self, uci: &'b mut Uci) -> Result<StdOption<UciPtr<'b>>> {
         let mut ptr = self.ptr.clone();
-        let mut uci = self.uci.lock().unwrap();
         let result = libuci_locked!(uci, {
             unsafe { uci_lookup_ptr(uci.ctx, &mut ptr, ptr::null_mut(), true) }
         });
-        let ptr = match handle_error(&mut uci, result)? {
+        let ptr = match handle_error(uci, result)? {
             Some(_) => {
                 if ptr.flags & uci_ptr_UCI_LOOKUP_COMPLETE == 0 {
                     return Ok(None);
@@ -201,37 +116,8 @@ impl<const S: usize> UciPtr<S> {
             None => return Ok(None),
         };
         Ok(Some(UciPtr {
-            uci: Arc::clone(&self.uci),
             ptr,
-            data: self.data.iter().map(Arc::clone).collect(),
+            _lt: &PhantomData,
         }))
     }
-
-    pub fn replace(
-        &self,
-        ptr: uci_ptr,
-        extra_data: impl Iterator<Item = CString>,
-    ) -> Result<UciPtr<S>> {
-        if self.ptr.target != ptr.target {
-            return Err(Error::Message("Invalid target provided".into()));
-        }
-        Ok(UciPtr {
-            ptr,
-            uci: Arc::clone(&self.uci),
-            data: self
-                .data
-                .iter()
-                .map(Arc::clone)
-                .chain(extra_data.map(Arc::new))
-                .collect(),
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    #[test]
-    fn iterator() {
-        // let iter = unsafe { UciListIter::new(list) };
-    }
 }
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 3134081..1d909fb 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -1,98 +1,202 @@
 use std::{
     ffi::{CStr, CString},
     iter,
+    ops::DerefMut,
     option::Option as StdOption,
-    sync::Arc,
+    ptr,
+    sync::{Arc, Mutex},
 };
 
-use libuci_sys::uci_set;
+use libuci_sys::{
+    uci_add_section, uci_ptr_UCI_LOOKUP_EXTENDED, uci_set, uci_type_UCI_TYPE_SECTION,
+};
 
-use crate::{config::handle_error, libuci_locked, Result};
+use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
 
 use super::{
     option::Option,
     package::Package,
-    ptr::{UciListIter, UciPtr, PTR_STAGE_SECTION},
+    ptr::{UciListIter, UciPtr},
 };
 
+pub enum SectionIdent<T> {
+    Anonymous,
+    Indexed(i32),
+    Named(T),
+}
+
+impl<T> SectionIdent<T>
+where
+    T: AsRef<CStr>,
+{
+    pub(crate) fn inner_ident(&self, type_: impl AsRef<CStr>) -> StdOption<CString> {
+        match self {
+            SectionIdent::Anonymous => None,
+            SectionIdent::Indexed(i) => {
+                let type_ = type_.as_ref().to_bytes();
+                let indexer = format!("[{i}]").into_bytes();
+                let ident: Vec<_> = iter::once('@' as u8)
+                    .chain(type_.into_iter().copied())
+                    .chain(indexer)
+                    .collect();
+                Some(CString::new(ident).unwrap())
+            }
+            SectionIdent::Named(name) => Some(name.as_ref().to_owned()),
+        }
+    }
+}
+
 /// represents a single section
 /// parent to different [Option]s
 pub struct Section {
-    type_: Arc<str>,
-    ptr: UciPtr<PTR_STAGE_SECTION>,
+    uci: Arc<Mutex<Uci>>,
+    package: Arc<CString>,
+    pub(crate) type_: Arc<CString>,
+    pub(crate) ident: Arc<SectionIdent<CString>>,
 }
 
 impl Section {
-    pub(crate) fn new(ptr: UciPtr<PTR_STAGE_SECTION>, type_: Arc<str>) -> Self {
-        Self { ptr, type_ }
+    pub(crate) fn new(
+        uci: Arc<Mutex<Uci>>,
+        package: Arc<CString>,
+        type_: Arc<CString>,
+        ident: Arc<SectionIdent<CString>>,
+    ) -> Self {
+        Self {
+            uci,
+            package,
+            type_,
+            ident,
+        }
     }
 
-    fn create_impl(&self) -> Result<UciPtr<PTR_STAGE_SECTION>> {
-        let type_ = CString::new(self.type_.as_bytes())?;
+    pub(crate) fn ptr<'a>(&'_ self, uci: &'a mut Uci) -> Result<StdOption<UciPtr<'a>>> {
+        let mut ptr = UciPtr::new();
+
+        let _ident_raw = match &*self.ident {
+            SectionIdent::Anonymous => return Ok(None),
+            i @ SectionIdent::Indexed(_) => {
+                let ident = i.inner_ident(self.type_.as_ref()).unwrap();
+                ptr.section = ident.as_ptr();
+                ptr.flags |= uci_ptr_UCI_LOOKUP_EXTENDED;
+                Some(ident) // keep this alive
+            }
+            SectionIdent::Named(s) => {
+                ptr.section = s.as_ptr();
+                None
+            }
+        };
 
-        // avoid modifying the long-lived uci_ptr
-        let mut ptr = self.ptr.clone();
-        ptr.value = type_.as_ptr();
+        ptr.target = uci_type_UCI_TYPE_SECTION;
+        ptr.package = self.package.as_c_str().as_ptr();
+        ptr.lookup(uci)
+    }
 
-        let uci = Arc::clone(&self.ptr.uci);
-        let mut uci = uci.lock().unwrap();
-        let result = libuci_locked!(uci, unsafe { uci_set(uci.ctx, &mut ptr) });
-        handle_error(&mut uci, result)?;
+    pub(crate) fn ensure<'a>(&'_ mut self, uci: StdOption<&'a mut Uci>) -> Result<UciPtr<'a>> {
+        let mut guard = None;
+        let uci = match uci {
+            Some(uci) => uci,
+            None => {
+                guard.replace(self.uci.lock().unwrap());
+                guard.as_deref_mut().unwrap()
+            }
+        };
+        let pkg_ptr = self
+            .package()
+            .ptr(uci)?
+            .ok_or_else(|| Error::EntryNotFound {
+                entry_identifier: self.package.to_str().unwrap().to_owned(),
+            })?;
+
+        let mut ptr = UciPtr::new();
+        ptr.target = uci_type_UCI_TYPE_SECTION;
+        ptr.p = pkg_ptr.p;
+
+        let result = match self.ident.as_ref() {
+            SectionIdent::Anonymous => {
+                let mut section_ptr = ptr::null_mut();
+                let result = libuci_locked!(uci, unsafe {
+                    uci_add_section(uci.ctx, ptr.p, self.type_.as_ptr(), &mut section_ptr)
+                });
+                ptr.s = section_ptr;
+
+                // persist created index in the ident
+                self.ident = Arc::new(unsafe { Package::section_ident(section_ptr) });
+
+                result
+            }
+            i @ SectionIdent::Indexed(_) => {
+                let ident = i.inner_ident(self.type_.as_ref()).unwrap();
+                ptr.flags |= uci_ptr_UCI_LOOKUP_EXTENDED;
+                ptr.section = ident.as_c_str().as_ptr();
+                ptr.value = self.type_.as_ptr();
+                let result = libuci_locked!(uci, unsafe { uci_set(uci.ctx, ptr.deref_mut()) });
+                ptr.section = ptr::null(); // CString is dropped after this context
+                result
+            }
+            SectionIdent::Named(name) => {
+                ptr.section = name.as_ptr();
+                ptr.value = self.type_.as_ptr();
+                libuci_locked!(uci, unsafe { uci_set(uci.ctx, ptr.deref_mut()) })
+            }
+        };
+        handle_error(uci, result)?;
 
-        self.ptr.replace(ptr, iter::once(type_))
+        Ok(ptr)
     }
 
-    pub fn create(&self) -> Result<()> {
-        self.create_impl()?;
+    pub fn create(&mut self) -> Result<()> {
+        self.ensure(None)?;
         Ok(())
     }
 
-    pub(crate) fn ensure(&self) -> Result<UciPtr<PTR_STAGE_SECTION>> {
-        match self.ptr.lookup()? {
-            Some(ptr) => return Ok(ptr),
-            None => self.create_impl(),
-        }
+    /// returns the name of the section item, None if it's anonymous
+    pub fn name(&self) -> StdOption<String> {
+        let ident = self.ident.as_ref().inner_ident(self.type_.as_ref());
+        ident.map(|cstr| cstr.into_string().unwrap())
     }
 
-    /// returns the name of the section item
-    pub fn name(&self) -> Result<&str> {
-        Ok(unsafe { CStr::from_ptr(self.ptr.section) }.to_str()?)
+    /// returns the type of the section
+    pub fn type_(&self) -> &str {
+        self.type_.to_str().unwrap()
     }
 
-    /// returns the type of the section, if it exists
-    pub fn type_(&self) -> Result<StdOption<String>> {
-        let ptr = match self.ptr.lookup()? {
-            Some(ptr) => ptr,
-            None => return Ok(None),
+    /// lists all options in this section
+    pub fn options(&self) -> Result<impl Iterator<Item = Option>> {
+        let mut uci = self.uci.lock().unwrap();
+        let ptr = match self.ptr(&mut uci)? {
+            Some(ptr) => &unsafe { *ptr.s }.options,
+            None => ptr::null(),
         };
-        Ok(Some(
-            unsafe { CStr::from_ptr((*ptr.s).type_) }
-                .to_str()?
-                .to_owned(),
-        ))
-    }
 
-    /// lists all options in this section
-    pub fn options(&self) -> impl Iterator<Item = Option> + use<'_> {
-        let iter = unsafe { UciListIter::new(&(*self.ptr.s).options) };
-        iter.map(move |elem| {
-            let name = unsafe { CStr::from_ptr((*elem).name) }.to_str().unwrap();
+        let uci = Arc::clone(&self.uci);
+        let package = Arc::clone(&self.package);
+        let section_type = Arc::clone(&self.type_);
+        let section_ident = Arc::clone(&self.ident);
+        Ok(UciListIter::new(ptr).map(move |elem| {
+            let name = unsafe { CStr::from_ptr((*elem).name) }.to_owned();
             Option::new(
-                self.ptr.with_option_name(name).unwrap(),
-                Arc::clone(&self.type_),
+                Arc::clone(&uci),
+                Arc::clone(&package),
+                (Arc::clone(&section_type), Arc::clone(&section_ident)),
+                Arc::new(name),
             )
-        })
+        }))
     }
 
     /// returns a specific [Option] by name
     /// also works if the option is not defined yet
     pub fn option(&self, name: impl AsRef<str>) -> Result<Option> {
-        let ptr = self.ptr.with_option_name(name)?;
-        Ok(Option::new(ptr, Arc::clone(&self.type_)))
+        let name = CString::new(name.as_ref())?;
+        Ok(Option::new(
+            Arc::clone(&self.uci),
+            Arc::clone(&self.package),
+            (Arc::clone(&self.type_), Arc::clone(&self.ident)),
+            Arc::new(name),
+        ))
     }
 
     pub fn package(&self) -> Package {
-        let ptr = self.ptr.parent();
-        Package::new(ptr)
+        Package::new(Arc::clone(&self.uci), Arc::clone(&self.package))
     }
 }

From ab2f18b62383492228612808000bc87d41d4707e Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 17:45:44 +0200
Subject: [PATCH 08/24] Avoid memleaks

---
 rust-uci/src/config/mod.rs | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 420ff6f..c3ece61 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -36,26 +36,34 @@ impl From<Uci> for Config {
 
 struct PackageIter {
     uci: Arc<Mutex<Uci>>,
-    ptr: *mut *mut c_char,
+    original: *mut *mut c_char,
+    current: *mut *mut c_char,
 }
 
 impl Iterator for PackageIter {
     type Item = Package;
 
     fn next(&mut self) -> StdOption<Self::Item> {
-        if self.ptr.is_null() {
+        if self.current.is_null() {
             return None;
         }
-        let name_ptr = unsafe { *self.ptr };
+        let name_ptr = unsafe { *self.current };
         if name_ptr.is_null() {
             return None;
         }
-        self.ptr = unsafe { self.ptr.add(1) };
+        self.current = unsafe { self.current.add(1) };
         let name = unsafe { CStr::from_ptr(name_ptr.cast()) }.to_owned();
+
         Some(Package::new(Arc::clone(&self.uci), Arc::new(name)))
     }
 }
 
+impl Drop for PackageIter {
+    fn drop(&mut self) {
+        unsafe { libc::free(self.original.cast::<std::os::raw::c_void>()) }
+    }
+}
+
 impl Config {
     pub fn new() -> Result<Self> {
         Ok(Uci::new()?.into())
@@ -81,7 +89,8 @@ impl Config {
         };
         Ok(PackageIter {
             uci: Arc::clone(&self.uci),
-            ptr,
+            original: ptr,
+            current: ptr,
         })
     }
 }

From fc285407b47fbdfd4bd7e8411de6d6ddf5487ffa Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 18:08:20 +0200
Subject: [PATCH 09/24] Improve ptr lookup

---
 rust-uci/src/config/mod.rs     |  2 +-
 rust-uci/src/config/package.rs | 13 +++++++++++--
 rust-uci/src/config/section.rs |  9 ++-------
 3 files changed, 14 insertions(+), 10 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index c3ece61..101f8bf 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -75,7 +75,7 @@ impl Config {
         let cname = CString::new(name.as_ref())?;
         let pkg = Package::new(Arc::clone(&self.uci), Arc::new(cname));
         let mut uci = self.uci.lock().unwrap();
-        Ok(pkg.ptr(&mut uci)?.map(|_| pkg))
+        Ok(pkg.ptr_opt(&mut uci)?.map(|_| pkg))
     }
 
     /// list all [Package]s in the config
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index edf8537..8fda80c 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -30,13 +30,22 @@ impl Package {
         Ok(self.name.to_str()?)
     }
 
-    pub(crate) fn ptr<'a>(&'_ self, uci: &'a mut Uci) -> Result<StdOption<UciPtr<'a>>> {
+    pub(crate) fn ptr_opt<'a>(&'_ self, uci: &'a mut Uci) -> Result<StdOption<UciPtr<'a>>> {
         let mut ptr = UciPtr::new();
         ptr.target = uci_type_UCI_TYPE_PACKAGE;
         ptr.package = self.name.as_c_str().as_ptr();
         ptr.lookup(uci)
     }
 
+    pub(crate) fn ptr<'a>(&'_ self, uci: &'a mut Uci) -> Result<UciPtr<'a>> {
+        match self.ptr_opt(uci)? {
+            Some(ptr) => Ok(ptr),
+            None => Err(Error::EntryNotFound {
+                entry_identifier: self.name()?.to_owned(),
+            }),
+        }
+    }
+
     pub(crate) unsafe fn section_ident(section: *const uci_section) -> SectionIdent<CString> {
         let elem = &unsafe { *section }.e;
         match unsafe { *section }.anonymous {
@@ -54,7 +63,7 @@ impl Package {
 
     pub fn sections(&self) -> Result<impl Iterator<Item = Section>> {
         let mut uci = self.uci.lock().unwrap();
-        let ptr = match self.ptr(&mut uci)? {
+        let ptr = match self.ptr_opt(&mut uci)? {
             Some(ptr) => unsafe { &(*ptr.p).sections },
             None => ptr::null(),
         };
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 1d909fb..146bf0c 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -11,7 +11,7 @@ use libuci_sys::{
     uci_add_section, uci_ptr_UCI_LOOKUP_EXTENDED, uci_set, uci_type_UCI_TYPE_SECTION,
 };
 
-use crate::{config::handle_error, error::Error, libuci_locked, Result, Uci};
+use crate::{config::handle_error, libuci_locked, Result, Uci};
 
 use super::{
     option::Option,
@@ -101,12 +101,7 @@ impl Section {
                 guard.as_deref_mut().unwrap()
             }
         };
-        let pkg_ptr = self
-            .package()
-            .ptr(uci)?
-            .ok_or_else(|| Error::EntryNotFound {
-                entry_identifier: self.package.to_str().unwrap().to_owned(),
-            })?;
+        let pkg_ptr = self.package().ptr(uci)?;
 
         let mut ptr = UciPtr::new();
         ptr.target = uci_type_UCI_TYPE_SECTION;

From 10b8eb784ff879d330b621686a62bda19b3a2eac Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 18:08:33 +0200
Subject: [PATCH 10/24] Allow save and commit

---
 rust-uci/src/config/mod.rs     | 16 ++++++++++++++++
 rust-uci/src/config/package.rs | 27 +++++++++++++++++++++++++--
 2 files changed, 41 insertions(+), 2 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 101f8bf..8064b99 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -93,6 +93,22 @@ impl Config {
             current: ptr,
         })
     }
+
+    /// save all packages to the temporary delta
+    pub fn save_all(&mut self) -> Result<()> {
+        for mut pkg in self.packages()? {
+            pkg.save()?;
+        }
+        Ok(())
+    }
+
+    /// commit all packages from the delta to the config on disk
+    pub fn commit_all(&mut self) -> Result<()> {
+        for mut pkg in self.packages()? {
+            pkg.commit()?;
+        }
+        Ok(())
+    }
 }
 
 fn handle_error(uci: &mut Uci, result: i32) -> Result<Option<()>> {
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 8fda80c..5f0f045 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -5,9 +5,13 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use libuci_sys::{uci_section, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
+use libuci_sys::{uci_commit, uci_save, uci_section, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
 
-use crate::{config::section::SectionIdent, Result, Uci};
+use crate::{
+    config::{handle_error, section::SectionIdent},
+    error::Error,
+    libuci_locked, Result, Uci,
+};
 
 use super::{
     ptr::{UciListIter, UciPtr},
@@ -106,4 +110,23 @@ impl Package {
             Arc::new(ident),
         ))
     }
+
+    /// save package delta to disk
+    pub fn save(&mut self) -> Result<()> {
+        let mut uci = self.uci.lock().unwrap();
+        let pkg = self.ptr(&mut uci)?.p;
+        let result = libuci_locked!(uci, unsafe { uci_save(uci.ctx, pkg) });
+        handle_error(&mut uci, result)?;
+        Ok(())
+    }
+
+    /// commit package delta into real config on disk
+    pub fn commit(&mut self) -> Result<()> {
+        let mut uci = self.uci.lock().unwrap();
+        let mut pkg = self.ptr(&mut uci)?.p;
+        // the uci cli seems to set `override=false` too, not sure what it means
+        let result = libuci_locked!(uci, unsafe { uci_commit(uci.ctx, &raw mut pkg, false) });
+        handle_error(&mut uci, result)?;
+        Ok(())
+    }
 }

From d64191498a9b40f2251e25daabda5612035c161d Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 18:58:43 +0200
Subject: [PATCH 11/24] Fix section creation

---
 rust-uci/src/config/package.rs | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 5f0f045..60b7315 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -51,9 +51,10 @@ impl Package {
     }
 
     pub(crate) unsafe fn section_ident(section: *const uci_section) -> SectionIdent<CString> {
-        let elem = &unsafe { *section }.e;
+        let elem = &raw const (*section).e;
+        let sections = &raw const (*(*section).package).sections;
         match unsafe { *section }.anonymous {
-            true => UciListIter::new(&unsafe { *(*section).package }.sections)
+            true => UciListIter::new(sections)
                 .enumerate()
                 .find(|(_, sect_elem)| *sect_elem == elem)
                 .map(|(i, _)| SectionIdent::Indexed(i as i32))

From 935f99d0f815851589bf02df63ed549c9fb2a722 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 18:58:54 +0200
Subject: [PATCH 12/24] Improve DX

---
 rust-uci/src/config/package.rs |  6 +++---
 rust-uci/src/config/section.rs | 24 ++++++++++++++++++++++++
 2 files changed, 27 insertions(+), 3 deletions(-)

diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 60b7315..7b9e845 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -90,15 +90,15 @@ impl Package {
 
     /// return a single [Section] by its name
     /// also works if the section is not defined yet
-    pub fn section(
+    pub fn section<T: AsRef<str>>(
         &self,
         type_: impl AsRef<str>,
-        ident: SectionIdent<impl AsRef<str>>,
+        ident: impl Into<SectionIdent<T>>,
     ) -> Result<Section> {
         let type_ = CString::new(type_.as_ref())?;
 
         use SectionIdent::*;
-        let ident = match ident {
+        let ident = match ident.into() {
             Anonymous => Anonymous,
             Indexed(i) => Indexed(i),
             Named(n) => Named(CString::new(n.as_ref())?),
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 146bf0c..7926dcf 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -46,6 +46,30 @@ where
     }
 }
 
+impl<'a> From<&'a str> for SectionIdent<&'a str> {
+    fn from(value: &'a str) -> Self {
+        Self::Named(value)
+    }
+}
+
+impl From<String> for SectionIdent<String> {
+    fn from(value: String) -> Self {
+        Self::Named(value)
+    }
+}
+
+impl From<i32> for SectionIdent<String> {
+    fn from(value: i32) -> Self {
+        Self::Indexed(value)
+    }
+}
+
+impl From<()> for SectionIdent<String> {
+    fn from(_value: ()) -> Self {
+        Self::Anonymous
+    }
+}
+
 /// represents a single section
 /// parent to different [Option]s
 pub struct Section {

From 978b401b6d9d84e3e2491798b25e93697aa43cd3 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 19:27:10 +0200
Subject: [PATCH 13/24] Fix implicit section creation

---
 rust-uci/src/config/option.rs  | 82 ++++++++++++++++++----------------
 rust-uci/src/config/section.rs | 21 ++++++++-
 2 files changed, 62 insertions(+), 41 deletions(-)

diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 74fb3d5..859a24a 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -17,21 +17,23 @@ use super::{
     section::{Section, SectionIdent},
 };
 
+pub type OptionMut = Option<true>;
+
 /// represents an option within a [Section]
-pub struct Option {
+pub struct Option<const MUT: bool = false> {
     uci: Arc<Mutex<Uci>>,
     package: Arc<CString>,
     section: (Arc<CString>, Arc<SectionIdent<CString>>),
     name: Arc<CString>,
 }
 
-impl Option {
+impl<const MUT: bool> Option<MUT> {
     pub(crate) fn new(
         uci: Arc<Mutex<Uci>>,
         package: Arc<CString>,
         section: (Arc<CString>, Arc<SectionIdent<CString>>),
         name: Arc<CString>,
-    ) -> Option {
+    ) -> Option<MUT> {
         Option {
             uci,
             package,
@@ -84,6 +86,44 @@ impl Option {
         )
     }
 
+    /// returns the current value of the option, None if not set
+    pub fn get<'a>(&'a self) -> Result<StdOption<Value>> {
+        let mut uci = self.uci.lock().unwrap();
+        let ptr = match self.ptr(&mut uci)? {
+            Some(ptr) => ptr,
+            None => return Ok(None),
+        };
+
+        let opt = ptr.o;
+
+        #[allow(non_upper_case_globals)]
+        match unsafe { *opt }.type_ {
+            uci_option_type_UCI_TYPE_STRING => {
+                let raw = unsafe { CStr::from_ptr((*opt).v.string) };
+                Ok(Value::String(raw.to_str()?.into()))
+            }
+            uci_option_type_UCI_TYPE_LIST => {
+                let mut result = Vec::new();
+                unsafe {
+                    uci_foreach_element(&(*opt).v.list, |elem| {
+                        let raw = CStr::from_ptr((*elem).name);
+                        result.push(raw);
+                    })
+                };
+                Ok(Value::List(
+                    result
+                        .into_iter()
+                        .map(|cstr| cstr.to_str().map_err(Into::into).map(Into::into))
+                        .collect::<Result<Vec<_>>>()?,
+                ))
+            }
+            t => return Err(Error::Message(format!("Unexpected option type: {t}"))),
+        }
+        .map(Some)
+    }
+}
+
+impl OptionMut {
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
@@ -120,42 +160,6 @@ impl Option {
 
         Ok(())
     }
-
-    /// returns the current value of the option, None if not set
-    pub fn get<'a>(&'a self) -> Result<StdOption<Value>> {
-        let mut uci = self.uci.lock().unwrap();
-        let ptr = match self.ptr(&mut uci)? {
-            Some(ptr) => ptr,
-            None => return Ok(None),
-        };
-
-        let opt = ptr.o;
-
-        #[allow(non_upper_case_globals)]
-        match unsafe { *opt }.type_ {
-            uci_option_type_UCI_TYPE_STRING => {
-                let raw = unsafe { CStr::from_ptr((*opt).v.string) };
-                Ok(Value::String(raw.to_str()?.into()))
-            }
-            uci_option_type_UCI_TYPE_LIST => {
-                let mut result = Vec::new();
-                unsafe {
-                    uci_foreach_element(&(*opt).v.list, |elem| {
-                        let raw = CStr::from_ptr((*elem).name);
-                        result.push(raw);
-                    })
-                };
-                Ok(Value::List(
-                    result
-                        .into_iter()
-                        .map(|cstr| cstr.to_str().map_err(Into::into).map(Into::into))
-                        .collect::<Result<Vec<_>>>()?,
-                ))
-            }
-            t => return Err(Error::Message(format!("Unexpected option type: {t}"))),
-        }
-        .map(Some)
-    }
 }
 
 /// represents the value of an [Option]
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 7926dcf..c5eef71 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -11,7 +11,10 @@ use libuci_sys::{
     uci_add_section, uci_ptr_UCI_LOOKUP_EXTENDED, uci_set, uci_type_UCI_TYPE_SECTION,
 };
 
-use crate::{config::handle_error, libuci_locked, Result, Uci};
+use crate::{
+    config::{handle_error, option::OptionMut},
+    libuci_locked, Result, Uci,
+};
 
 use super::{
     option::Option,
@@ -207,7 +210,21 @@ impl Section {
     /// also works if the option is not defined yet
     pub fn option(&self, name: impl AsRef<str>) -> Result<Option> {
         let name = CString::new(name.as_ref())?;
-        Ok(Option::new(
+        Ok(Option::<false>::new(
+            Arc::clone(&self.uci),
+            Arc::clone(&self.package),
+            (Arc::clone(&self.type_), Arc::clone(&self.ident)),
+            Arc::new(name),
+        ))
+    }
+
+    /// works like [Self::option], but ensures the section exists first
+    /// this then allows to modify the option
+    /// (which requires the section to exist)
+    pub fn option_mut(&mut self, name: impl AsRef<str>) -> Result<OptionMut> {
+        self.ensure(None)?;
+        let name = CString::new(name.as_ref())?;
+        Ok(Option::<true>::new(
             Arc::clone(&self.uci),
             Arc::clone(&self.package),
             (Arc::clone(&self.type_), Arc::clone(&self.ident)),

From 0dd250f699e24fc0cbd0731af1743fffae01a29c Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 19:28:49 +0200
Subject: [PATCH 14/24] Improve handling of anonymous sections

---
 rust-uci/src/config/package.rs | 22 +++-------------------
 rust-uci/src/config/section.rs |  5 +++--
 2 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 7b9e845..e8df4dd 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -5,7 +5,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use libuci_sys::{uci_commit, uci_save, uci_section, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
+use libuci_sys::{uci_commit, uci_save, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
 
 use crate::{
     config::{handle_error, section::SectionIdent},
@@ -50,22 +50,6 @@ impl Package {
         }
     }
 
-    pub(crate) unsafe fn section_ident(section: *const uci_section) -> SectionIdent<CString> {
-        let elem = &raw const (*section).e;
-        let sections = &raw const (*(*section).package).sections;
-        match unsafe { *section }.anonymous {
-            true => UciListIter::new(sections)
-                .enumerate()
-                .find(|(_, sect_elem)| *sect_elem == elem)
-                .map(|(i, _)| SectionIdent::Indexed(i as i32))
-                .unwrap_or(SectionIdent::Anonymous),
-            false => {
-                let name = unsafe { CStr::from_ptr((*elem).name) }.to_owned();
-                SectionIdent::Named(name)
-            }
-        }
-    }
-
     pub fn sections(&self) -> Result<impl Iterator<Item = Section>> {
         let mut uci = self.uci.lock().unwrap();
         let ptr = match self.ptr_opt(&mut uci)? {
@@ -78,12 +62,12 @@ impl Package {
         Ok(UciListIter::new(ptr).map(move |elem| {
             let sect = unsafe { uci_to_section(elem) };
             let type_ = unsafe { CStr::from_ptr((*sect).type_) }.to_owned();
-            let ident = unsafe { Self::section_ident(sect) };
+            let name = unsafe { CStr::from_ptr((*elem).name) }.to_owned();
             Section::new(
                 Arc::clone(&uci),
                 Arc::clone(&package),
                 Arc::new(type_),
-                Arc::new(ident),
+                Arc::new(SectionIdent::Named(name)),
             )
         }))
     }
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index c5eef71..3bbc6ee 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -142,8 +142,9 @@ impl Section {
                 });
                 ptr.s = section_ptr;
 
-                // persist created index in the ident
-                self.ident = Arc::new(unsafe { Package::section_ident(section_ptr) });
+                // persist created name in the ident
+                let name = unsafe { CStr::from_ptr((*section_ptr).e.name) }.to_owned();
+                self.ident = Arc::new(SectionIdent::Named(name));
 
                 result
             }

From 79343e9a9282aa94eee1ea1dce548f12b1c7368f Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 19:29:05 +0200
Subject: [PATCH 15/24] Fix listing of options

---
 rust-uci/src/config/section.rs | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 3bbc6ee..c71c532 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -187,16 +187,16 @@ impl Section {
     /// lists all options in this section
     pub fn options(&self) -> Result<impl Iterator<Item = Option>> {
         let mut uci = self.uci.lock().unwrap();
-        let ptr = match self.ptr(&mut uci)? {
-            Some(ptr) => &unsafe { *ptr.s }.options,
-            None => ptr::null(),
-        };
+        let section = self.ptr(&mut uci)?.map(|p| unsafe { *p.s });
+        let option_list = section
+            .map(|l| &raw const l.options)
+            .unwrap_or_else(ptr::null);
 
         let uci = Arc::clone(&self.uci);
         let package = Arc::clone(&self.package);
         let section_type = Arc::clone(&self.type_);
         let section_ident = Arc::clone(&self.ident);
-        Ok(UciListIter::new(ptr).map(move |elem| {
+        Ok(UciListIter::new(option_list).map(move |elem| {
             let name = unsafe { CStr::from_ptr((*elem).name) }.to_owned();
             Option::new(
                 Arc::clone(&uci),

From 30d5d5d3c9b31fe0602ce2bf85ef3dc4403b1b4e Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 19:36:36 +0200
Subject: [PATCH 16/24] Improve options list DX

---
 rust-uci/src/config/section.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index c71c532..37844d5 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -185,7 +185,7 @@ impl Section {
     }
 
     /// lists all options in this section
-    pub fn options(&self) -> Result<impl Iterator<Item = Option>> {
+    pub fn options(&self) -> Result<impl Iterator<Item = OptionMut>> {
         let mut uci = self.uci.lock().unwrap();
         let section = self.ptr(&mut uci)?.map(|p| unsafe { *p.s });
         let option_list = section

From bfb726350242bd15b9a053060010f2f28749dc2f Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 19:37:14 +0200
Subject: [PATCH 17/24] Add tests

---
 rust-uci/src/config/mod.rs | 242 ++++++++++++++++++++++++++++++++++---
 1 file changed, 226 insertions(+), 16 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 8064b99..926d150 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -172,6 +172,177 @@ mod tests {
         assert_eq!(Some(option::Value::String("auto".into())), val);
     }
 
+    #[test]
+    fn set_option_existing() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+            ",
+        )
+        .unwrap();
+
+        let cfg = Config::from(uci);
+        let mut opt = cfg
+            .package("wireless")
+            .unwrap()
+            .unwrap()
+            .section("wifi-device", "pdev0")
+            .unwrap()
+            .option_mut("channel")
+            .unwrap();
+        opt.set("44").unwrap();
+        assert_eq!(Value::String("44".into()), opt.get().unwrap().unwrap());
+    }
+
+    #[test]
+    fn set_option_new() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+            ",
+        )
+        .unwrap();
+        let save_dir = uci.get_save_dir().unwrap().to_owned();
+        let config_dir = uci.get_config_dir().unwrap().to_owned();
+
+        let mut cfg = Config::from(uci);
+
+        {
+            let mut opt = cfg
+                .package("wireless")
+                .unwrap()
+                .unwrap()
+                .section("wifi-device", "pdev0")
+                .unwrap()
+                .option_mut("disabled")
+                .unwrap();
+            opt.set("1").unwrap();
+            assert_eq!(Value::String("1".into()), opt.get().unwrap().unwrap());
+        }
+
+        {
+            // re-get, unsaved
+            let v = cfg
+                .package("wireless")
+                .unwrap()
+                .unwrap()
+                .section("wifi-device", "pdev0")
+                .unwrap()
+                .option("disabled")
+                .unwrap()
+                .get()
+                .unwrap()
+                .unwrap();
+            assert_eq!(Value::String("1".into()), v);
+        }
+
+        cfg.save_all().unwrap();
+
+        {
+            // recreate uci instance
+            let mut uci = Uci::new().unwrap();
+            uci.set_save_dir(&save_dir).unwrap();
+            uci.set_config_dir(&config_dir).unwrap();
+            let cfg = Config::from(uci);
+
+            // saved
+            let v = cfg
+                .package("wireless")
+                .unwrap()
+                .unwrap()
+                .section("wifi-device", "pdev0")
+                .unwrap()
+                .option("disabled")
+                .unwrap()
+                .get()
+                .unwrap()
+                .unwrap();
+            assert_eq!(Value::String("1".into()), v);
+        }
+    }
+
+    #[test]
+    fn set_option_new_section() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+            ",
+        )
+        .unwrap();
+
+        let cfg = Config::from(uci);
+
+        {
+            let mut opt = cfg
+                .package("wireless")
+                .unwrap()
+                .unwrap()
+                .section("wifi-device", "pdev1")
+                .unwrap()
+                .option_mut("channel")
+                .unwrap();
+            opt.set("auto").unwrap();
+            assert_eq!(Value::String("auto".into()), opt.get().unwrap().unwrap());
+        }
+
+        {
+            let v = cfg
+                .package("wireless")
+                .unwrap()
+                .unwrap()
+                .section("wifi-device", "pdev1")
+                .unwrap()
+                .option("channel")
+                .unwrap()
+                .get()
+                .unwrap()
+                .unwrap();
+            assert_eq!(Value::String("auto".into()), v);
+        }
+    }
+
+    #[test]
+    fn create_section_anonymous() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+            ",
+        )
+        .unwrap();
+
+        let cfg = Config::from(uci);
+        let mut section = cfg
+            .package("wireless")
+            .unwrap()
+            .unwrap()
+            .section("wifi-device", ())
+            .unwrap();
+        // will implictly create the option
+        section.option_mut("channel").unwrap().set("auto").unwrap();
+        assert_eq!(
+            Value::String("auto".into()),
+            section.option("channel").unwrap().get().unwrap().unwrap()
+        );
+        assert!(section.name().unwrap().len() > 0);
+
+        let pkg = cfg.package("wireless").unwrap().unwrap();
+        for sect in pkg.sections().unwrap() {
+            println!("{}", sect.name().unwrap());
+        }
+    }
+
     #[test]
     fn list_packages() {
         let (uci, tmp) = setup_uci().unwrap();
@@ -205,38 +376,77 @@ mod tests {
     }
 
     #[test]
-    fn ptr_mutability() {
+    fn list_sections() {
         let (uci, tmp) = setup_uci().unwrap();
         std::fs::write(
             &tmp.path().join("config/wireless"),
             "
             config wifi-device 'pdev0'
                     option channel 'auto'
+
+            config wifi-device 'pdev1'
+                    list channel '44'
+                    list channel '48'
+
+            config wifi-device
+                    option channel '56'
             ",
         )
         .unwrap();
 
-        let cfg: Config = uci.into();
+        let cfg = Config::from(uci);
         let pkg = cfg.package("wireless").unwrap().unwrap();
-        for section in pkg.sections().unwrap() {
-            let mut opt = section.option("channel").unwrap();
-            let val_before = opt.get().unwrap();
-            opt.set("foo").unwrap();
-            let val_after = opt.get().unwrap();
-            assert_eq!(Some(Value::String("auto".into())), val_before);
-            assert_eq!(Some(Value::String("foo".into())), val_after);
+        let sections: Vec<_> = pkg.sections().unwrap().collect();
+        assert_eq!(3, sections.len());
+
+        for section in &sections {
+            let channel = section.option("channel").unwrap().get().unwrap().unwrap();
+            match section.name().unwrap().as_str() {
+                "pdev0" => assert_eq!(Value::String("auto".into()), channel),
+                "pdev1" => assert_eq!(Value::List(vec!["44".into(), "48".into()]), channel),
+                _ => assert_eq!(Value::String("56".into()), channel),
+            }
         }
+    }
 
-        let mut opt = cfg
+    #[test]
+    fn list_options() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                list channel '44'
+                list channel '48'
+                option disabled '0'
+                option txpower '56'
+                option country 'DE'
+                option log_level '4'
+            ",
+        )
+        .unwrap();
+
+        let cfg = Config::from(uci);
+        let section = cfg
             .package("wireless")
             .unwrap()
             .unwrap()
-            .section("wifi-device", SectionIdent::Named("pdev1"))
-            .unwrap()
-            .option("channel")
+            .section("wifi-device", "pdev0")
             .unwrap();
-        opt.set("foo").unwrap();
-        opt.set("auto").unwrap();
-        println!("done!");
+        for opt in section.options().unwrap() {
+            let v = opt.get().unwrap().unwrap();
+            let expected = match opt.name() {
+                "channel" => {
+                    assert_eq!(Value::List(vec!["44".into(), "48".into()]), v);
+                    continue;
+                }
+                "disabled" => "0",
+                "txpower" => "56",
+                "country" => "DE",
+                "log_level" => "4",
+                _ => panic!("unexpected option: {}", opt.name()),
+            };
+            assert_eq!(Value::String(expected.into()), v);
+        }
     }
 }

From 3f678facca8a0042e4ce79539323490b1c4075a7 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 19:52:16 +0200
Subject: [PATCH 18/24] Allow getting sections by type

---
 rust-uci/src/config/mod.rs     | 37 ++++++++++++++++++++++++++++++++++
 rust-uci/src/config/package.rs | 24 +++++++++++++++++++---
 2 files changed, 58 insertions(+), 3 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 926d150..8ca3275 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -400,6 +400,7 @@ mod tests {
         assert_eq!(3, sections.len());
 
         for section in &sections {
+            assert_eq!("wifi-device", section.type_());
             let channel = section.option("channel").unwrap().get().unwrap().unwrap();
             match section.name().unwrap().as_str() {
                 "pdev0" => assert_eq!(Value::String("auto".into()), channel),
@@ -409,6 +410,42 @@ mod tests {
         }
     }
 
+    #[test]
+    fn list_sections_by_type() {
+        let (uci, tmp) = setup_uci().unwrap();
+        std::fs::write(
+            &tmp.path().join("config/wireless"),
+            "
+            config wifi-device 'pdev0'
+                    option channel 'auto'
+
+            config wifi-iface 'wlan0'
+                    option device 'pdev0'
+
+            config wifi-iface
+                    option device 'pdev0'
+            ",
+        )
+        .unwrap();
+
+        let cfg = Config::from(uci);
+        let pkg = cfg.package("wireless").unwrap().unwrap();
+
+        let all_sections: Vec<_> = pkg.sections().unwrap().collect();
+        assert_eq!(3, all_sections.len());
+
+        let iface_sections: Vec<_> = pkg.sections_by_type("wifi-iface").unwrap().collect();
+        assert_eq!(2, iface_sections.len());
+
+        for sect in iface_sections {
+            assert_eq!("wifi-iface", sect.type_());
+            assert_eq!(
+                Value::String("pdev0".into()),
+                sect.option("device").unwrap().get().unwrap().unwrap()
+            )
+        }
+    }
+
     #[test]
     fn list_options() {
         let (uci, tmp) = setup_uci().unwrap();
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index e8df4dd..8914b69 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -5,7 +5,7 @@ use std::{
     sync::{Arc, Mutex},
 };
 
-use libuci_sys::{uci_commit, uci_save, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
+use libuci_sys::{uci_commit, uci_element, uci_save, uci_to_section, uci_type_UCI_TYPE_PACKAGE};
 
 use crate::{
     config::{handle_error, section::SectionIdent},
@@ -50,7 +50,10 @@ impl Package {
         }
     }
 
-    pub fn sections(&self) -> Result<impl Iterator<Item = Section>> {
+    fn sections_impl<F: FnMut(&*const uci_element) -> bool>(
+        &self,
+        filter: F,
+    ) -> Result<impl Iterator<Item = Section>> {
         let mut uci = self.uci.lock().unwrap();
         let ptr = match self.ptr_opt(&mut uci)? {
             Some(ptr) => unsafe { &(*ptr.p).sections },
@@ -59,7 +62,7 @@ impl Package {
         drop(uci);
         let uci = Arc::clone(&self.uci);
         let package = Arc::clone(&self.name);
-        Ok(UciListIter::new(ptr).map(move |elem| {
+        Ok(UciListIter::new(ptr).filter(filter).map(move |elem| {
             let sect = unsafe { uci_to_section(elem) };
             let type_ = unsafe { CStr::from_ptr((*sect).type_) }.to_owned();
             let name = unsafe { CStr::from_ptr((*elem).name) }.to_owned();
@@ -72,6 +75,21 @@ impl Package {
         }))
     }
 
+    pub fn sections(&self) -> Result<impl Iterator<Item = Section>> {
+        self.sections_impl(|_| true)
+    }
+
+    pub fn sections_by_type(
+        &self,
+        type_: impl AsRef<str>,
+    ) -> Result<impl Iterator<Item = Section>> {
+        let type_ = CString::new(type_.as_ref())?;
+        self.sections_impl(move |e| {
+            let elem_type = unsafe { CStr::from_ptr((*uci_to_section(*e)).type_) };
+            elem_type == type_.as_c_str()
+        })
+    }
+
     /// return a single [Section] by its name
     /// also works if the section is not defined yet
     pub fn section<T: AsRef<str>>(

From 7be8d6b8fd7c72a78550105b4d3b46308b400c5a Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sat, 2 May 2026 20:04:39 +0200
Subject: [PATCH 19/24] Make some useful types public

---
 rust-uci/src/config/mod.rs | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 8ca3275..e06a404 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -12,13 +12,15 @@ use crate::{
 };
 
 mod option;
+pub use option::{Option, OptionMut, Value};
 
 mod package;
-use package::Package;
+pub use package::Package;
 
 mod ptr;
 
 mod section;
+pub use section::{Section, SectionIdent};
 
 /// represents the root of the config tree
 /// It's the parent structure to [Package]s
@@ -111,7 +113,7 @@ impl Config {
     }
 }
 
-fn handle_error(uci: &mut Uci, result: i32) -> Result<Option<()>> {
+fn handle_error(uci: &mut Uci, result: i32) -> Result<StdOption<()>> {
     match result {
         UCI_OK => Ok(Some(())),
         UCI_ERR_NOTFOUND => {

From 22a4b9513d36edc2e24609a4652f4746e9dcbc24 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sun, 3 May 2026 14:51:32 +0200
Subject: [PATCH 20/24] Avoid using dangerous library locking

---
 rust-uci/src/config/mod.rs     | 2 +-
 rust-uci/src/config/option.rs  | 2 +-
 rust-uci/src/config/package.rs | 4 ++--
 rust-uci/src/config/ptr.rs     | 5 ++---
 rust-uci/src/config/section.rs | 6 +++---
 rust-uci/src/lib.rs            | 6 ++++++
 6 files changed, 15 insertions(+), 10 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index e06a404..9596327 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -84,7 +84,7 @@ impl Config {
     pub fn packages<'a>(&self) -> Result<impl Iterator<Item = Package>> {
         let mut uci = self.uci.lock().unwrap();
         let mut list = std::ptr::null_mut();
-        let result = libuci_locked!(uci, { unsafe { uci_list_configs(uci.ctx, &mut list) } });
+        let result = libuci_locked!(unsafe { uci_list_configs(uci.ctx, &mut list) });
         let ptr = match handle_error(&mut uci, result)? {
             Some(_) => list,
             None => std::ptr::null_mut(),
diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 859a24a..9315fb7 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -155,7 +155,7 @@ impl OptionMut {
         let ptr = ptr.deref_mut() as *mut _;
 
         let mut uci = self.uci.lock().unwrap();
-        let result = libuci_locked!(uci, { unsafe { uci_add_list(uci.ctx, ptr) } });
+        let result = libuci_locked!(unsafe { uci_add_list(uci.ctx, &raw mut *ptr.deref_mut()) });
         handle_error(&mut uci, result)?;
 
         Ok(())
diff --git a/rust-uci/src/config/package.rs b/rust-uci/src/config/package.rs
index 8914b69..2063d64 100644
--- a/rust-uci/src/config/package.rs
+++ b/rust-uci/src/config/package.rs
@@ -118,7 +118,7 @@ impl Package {
     pub fn save(&mut self) -> Result<()> {
         let mut uci = self.uci.lock().unwrap();
         let pkg = self.ptr(&mut uci)?.p;
-        let result = libuci_locked!(uci, unsafe { uci_save(uci.ctx, pkg) });
+        let result = libuci_locked!(unsafe { uci_save(uci.ctx, pkg) });
         handle_error(&mut uci, result)?;
         Ok(())
     }
@@ -128,7 +128,7 @@ impl Package {
         let mut uci = self.uci.lock().unwrap();
         let mut pkg = self.ptr(&mut uci)?.p;
         // the uci cli seems to set `override=false` too, not sure what it means
-        let result = libuci_locked!(uci, unsafe { uci_commit(uci.ctx, &raw mut pkg, false) });
+        let result = libuci_locked!(unsafe { uci_commit(uci.ctx, &raw mut pkg, false) });
         handle_error(&mut uci, result)?;
         Ok(())
     }
diff --git a/rust-uci/src/config/ptr.rs b/rust-uci/src/config/ptr.rs
index 7f7b349..8767fed 100644
--- a/rust-uci/src/config/ptr.rs
+++ b/rust-uci/src/config/ptr.rs
@@ -103,9 +103,8 @@ impl<'a> UciPtr<'a> {
 
     pub fn lookup<'b>(&'_ mut self, uci: &'b mut Uci) -> Result<StdOption<UciPtr<'b>>> {
         let mut ptr = self.ptr.clone();
-        let result = libuci_locked!(uci, {
-            unsafe { uci_lookup_ptr(uci.ctx, &mut ptr, ptr::null_mut(), true) }
-        });
+        let result =
+            libuci_locked!(unsafe { uci_lookup_ptr(uci.ctx, &mut ptr, ptr::null_mut(), true) });
         let ptr = match handle_error(uci, result)? {
             Some(_) => {
                 if ptr.flags & uci_ptr_UCI_LOOKUP_COMPLETE == 0 {
diff --git a/rust-uci/src/config/section.rs b/rust-uci/src/config/section.rs
index 37844d5..3eb1c33 100644
--- a/rust-uci/src/config/section.rs
+++ b/rust-uci/src/config/section.rs
@@ -137,7 +137,7 @@ impl Section {
         let result = match self.ident.as_ref() {
             SectionIdent::Anonymous => {
                 let mut section_ptr = ptr::null_mut();
-                let result = libuci_locked!(uci, unsafe {
+                let result = libuci_locked!(unsafe {
                     uci_add_section(uci.ctx, ptr.p, self.type_.as_ptr(), &mut section_ptr)
                 });
                 ptr.s = section_ptr;
@@ -153,14 +153,14 @@ impl Section {
                 ptr.flags |= uci_ptr_UCI_LOOKUP_EXTENDED;
                 ptr.section = ident.as_c_str().as_ptr();
                 ptr.value = self.type_.as_ptr();
-                let result = libuci_locked!(uci, unsafe { uci_set(uci.ctx, ptr.deref_mut()) });
+                let result = libuci_locked!(unsafe { uci_set(uci.ctx, ptr.deref_mut()) });
                 ptr.section = ptr::null(); // CString is dropped after this context
                 result
             }
             SectionIdent::Named(name) => {
                 ptr.section = name.as_ptr();
                 ptr.value = self.type_.as_ptr();
-                libuci_locked!(uci, unsafe { uci_set(uci.ctx, ptr.deref_mut()) })
+                libuci_locked!(unsafe { uci_set(uci.ctx, ptr.deref_mut()) })
             }
         };
         handle_error(uci, result)?;
diff --git a/rust-uci/src/lib.rs b/rust-uci/src/lib.rs
index c693441..ff33578 100644
--- a/rust-uci/src/lib.rs
+++ b/rust-uci/src/lib.rs
@@ -89,6 +89,12 @@ mod macros {
         ($self:ident, $call:expr) => {{
             // Lock global library mutex, if we aren't already holding it in a function call higher up
             // in the stack.
+            //
+            // todo(mraerino): This is dangerous for when $call has any code that
+            // calls `return` or uses the `?` postfix operator
+            // in those cases, the lock guard is dropped, but `$self.lock_held`
+            // is not set back to false, causing the next call to assume the lock
+            // is held when it is not
             let libuci_lock_guard = if !$self.lock_held {
                 let libuci_lock_guard = Some(
                     $crate::macros::LIBRARY_LOCK

From f0bc46568435d947148d7d418a56c4434bfdbe36 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sun, 3 May 2026 14:52:51 +0200
Subject: [PATCH 21/24] Improve DX of Value type

---
 rust-uci/src/config/option.rs | 53 ++++++++++++++++++++++++++---------
 1 file changed, 40 insertions(+), 13 deletions(-)

diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 9315fb7..bad2b2a 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,3 +1,4 @@
+use core::slice;
 use std::{
     ffi::{CStr, CString},
     ops::DerefMut,
@@ -166,26 +167,54 @@ impl OptionMut {
 #[derive(Debug)]
 pub enum Value {
     String(String),
-    Boolean(bool),
-    Integer(i64),
     List(Vec<String>),
 }
 
-impl From<String> for Value {
-    fn from(value: String) -> Self {
-        Self::String(value.into())
+impl Value {
+    pub fn to_str(&self) -> StdOption<&str> {
+        match self {
+            Value::String(n) => Some(n),
+            _ => None,
+        }
     }
 }
 
-impl From<bool> for Value {
-    fn from(value: bool) -> Self {
-        Self::Boolean(value)
+pub enum ValueIter<'a> {
+    String(StdOption<&'a String>),
+    List(slice::Iter<'a, String>),
+}
+
+impl<'a> Iterator for ValueIter<'a> {
+    type Item = &'a str;
+
+    fn next(&mut self) -> StdOption<Self::Item> {
+        match self {
+            ValueIter::String(opt) => opt.take(),
+            ValueIter::List(iter) => iter.next(),
+        }
+        .map(String::as_str)
+    }
+}
+
+impl<'a> IntoIterator for &'a Value {
+    type Item = &'a str;
+
+    type IntoIter = ValueIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        match self {
+            Value::String(val) => ValueIter::String(Some(val)),
+            Value::List(items) => ValueIter::List(items.iter()),
+        }
     }
 }
 
-impl From<i64> for Value {
-    fn from(value: i64) -> Self {
-        Self::Integer(value)
+impl<T> From<T> for Value
+where
+    T: ToString,
+{
+    fn from(value: T) -> Self {
+        Self::String(value.to_string())
     }
 }
 
@@ -193,8 +222,6 @@ impl<'a> PartialEq for Value {
     fn eq(&self, other: &Self) -> bool {
         match (self, other) {
             (Self::String(l0), Self::String(r0)) => l0 == r0,
-            (Self::Boolean(l0), Self::Boolean(r0)) => l0 == r0,
-            (Self::Integer(l0), Self::Integer(r0)) => l0 == r0,
             (Self::List(l0), Self::List(r0)) => l0 == r0,
             _ => false,
         }

From 321c1e406c82235c10b705528192dde99339215f Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sun, 3 May 2026 14:53:02 +0200
Subject: [PATCH 22/24] Remove printing from test

---
 rust-uci/src/config/mod.rs | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/rust-uci/src/config/mod.rs b/rust-uci/src/config/mod.rs
index 9596327..25cd757 100644
--- a/rust-uci/src/config/mod.rs
+++ b/rust-uci/src/config/mod.rs
@@ -340,9 +340,7 @@ mod tests {
         assert!(section.name().unwrap().len() > 0);
 
         let pkg = cfg.package("wireless").unwrap().unwrap();
-        for sect in pkg.sections().unwrap() {
-            println!("{}", sect.name().unwrap());
-        }
+        assert_eq!(2, pkg.sections().unwrap().count());
     }
 
     #[test]

From a66774a81b9be5d108a397bf00b4417dd0d11232 Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sun, 3 May 2026 14:53:22 +0200
Subject: [PATCH 23/24] Improve DX of setting an option

---
 rust-uci/src/config/option.rs | 49 +++++++++++++++++++++++------------
 1 file changed, 32 insertions(+), 17 deletions(-)

diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index bad2b2a..423de64 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -7,7 +7,7 @@ use std::{
 };
 
 use libuci_sys::{
-    uci_add_list, uci_foreach_element, uci_option_type_UCI_TYPE_LIST,
+    uci_add_list, uci_delete, uci_foreach_element, uci_option_type_UCI_TYPE_LIST,
     uci_option_type_UCI_TYPE_STRING, uci_set, uci_type_UCI_TYPE_OPTION,
 };
 
@@ -57,10 +57,9 @@ impl<const MUT: bool> Option<MUT> {
         ptr.lookup(uci)
     }
 
-    fn ptr_ensure<'a>(&'a mut self) -> Result<UciPtr<'a>> {
-        let mut uci = self.uci.lock().unwrap();
+    fn ptr_ensure<'a>(&'_ mut self, uci: &'a mut Uci) -> Result<UciPtr<'a>> {
         let mut section = self.section();
-        let section_ptr = section.ensure(Some(&mut uci))?;
+        let section_ptr = section.ensure(Some(uci))?;
 
         // update ident to match newly created item
         self.section.1 = Arc::clone(&section.ident);
@@ -128,17 +127,32 @@ impl OptionMut {
     /// sets the value of the option, overriding the previous value
     /// will create the [Package] or [Section] along the way if they do
     /// not exist
-    pub fn set(&mut self, value: impl AsRef<str>) -> Result<()> {
-        let value = CString::new(value.as_ref())?;
-
-        let mut ptr = self.ptr_ensure()?;
-        ptr.value = value.as_ptr();
-        let ptr = ptr.deref_mut() as *mut _;
-
-        let mut uci = self.uci.lock().unwrap();
-        let result = libuci_locked!(uci, { unsafe { uci_set(uci.ctx, ptr) } });
-        handle_error(&mut uci, result)?;
-
+    pub fn set(&mut self, value: impl Into<Value>) -> Result<()> {
+        let uci = Arc::clone(&self.uci);
+        let mut uci = uci.lock().unwrap();
+        let ptr = self.ptr_ensure(&mut uci)?;
+        let mut ptr: UciPtr<'static> = unsafe { std::mem::transmute(ptr) };
+        match value.into() {
+            Value::String(s) => {
+                let value = CString::new(s)?;
+                ptr.value = value.as_ptr();
+
+                let result = libuci_locked!(unsafe { uci_set(uci.ctx, &raw mut *ptr.deref_mut()) });
+                handle_error(&mut uci, result)?;
+            }
+            Value::List(items) => {
+                libuci_locked!({
+                    let result = unsafe { uci_delete(uci.ctx, &raw mut *ptr.deref_mut()) };
+                    handle_error(&mut uci, result)?;
+                    for item in items {
+                        let val = CString::new(item)?;
+                        ptr.value = val.as_ptr();
+                        let result = unsafe { uci_add_list(uci.ctx, &raw mut *ptr.deref_mut()) };
+                        handle_error(&mut uci, result)?;
+                    }
+                });
+            }
+        };
         Ok(())
     }
 
@@ -151,9 +165,10 @@ impl OptionMut {
     pub fn add_list(&mut self, value: impl AsRef<str>) -> Result<()> {
         let value = CString::new(value.as_ref())?;
 
-        let mut ptr = self.ptr_ensure()?;
+        let uci = Arc::clone(&self.uci);
+        let mut uci = uci.lock().unwrap();
+        let mut ptr = self.ptr_ensure(&mut uci)?;
         ptr.value = value.as_ptr();
-        let ptr = ptr.deref_mut() as *mut _;
 
         let mut uci = self.uci.lock().unwrap();
         let result = libuci_locked!(unsafe { uci_add_list(uci.ctx, &raw mut *ptr.deref_mut()) });

From 2ff749c5d49cd0f004966b64daebbff78e2f288e Mon Sep 17 00:00:00 2001
From: Marcus Weiner <marcus.weiner@gmail.com>
Date: Sun, 3 May 2026 14:57:56 +0200
Subject: [PATCH 24/24] Add utility method for creating list value

---
 rust-uci/src/config/option.rs | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/rust-uci/src/config/option.rs b/rust-uci/src/config/option.rs
index 423de64..47e2194 100644
--- a/rust-uci/src/config/option.rs
+++ b/rust-uci/src/config/option.rs
@@ -1,5 +1,6 @@
 use core::slice;
 use std::{
+    borrow::Cow,
     ffi::{CStr, CString},
     ops::DerefMut,
     option::Option as StdOption,
@@ -186,6 +187,11 @@ pub enum Value {
 }
 
 impl Value {
+    pub fn list<'a, I: Into<Cow<'a, str>>>(val: impl IntoIterator<Item = I>) -> Self {
+        let v = val.into_iter().map(|s| s.into().to_string()).collect();
+        Self::List(v)
+    }
+
     pub fn to_str(&self) -> StdOption<&str> {
         match self {
             Value::String(n) => Some(n),