crates/nonstick: src/libpam/handle.rs comparison

comparison src/libpam/handle.rs @ 163:a75a66cb4181

Add end-to-end tests; fix issues found by tests. - Create tests and installer/remover shell script - Fix Pointer/pointee problems - Add Debug formatting - Misc cleanup

author	Paul Fisher <paul@pfish.zone>
date	Mon, 14 Jul 2025 17:40:11 -0400
parents	634cd5f2ac8b
children	2f5913131295

comparison

equal deleted inserted replaced

-:180237d0b498
+:a75a66cb4181
 use std::cell::Cell;
 use std::ffi::{c_char, c_int, c_void, CString, OsStr, OsString};
 use std::mem::ManuallyDrop;
 use std::os::unix::ffi::OsStrExt;
 use std::ptr::NonNull;
-use std::{fmt, ptr};
+use std::{any, fmt, ptr};
 /// An owned PAM handle.
 pub struct LibPamTransaction<C: Conversation> {
-/// The handle itself.
+/// The handle itself.  We guarantee this will not be null.
-handle: ManuallyDrop<LibPamHandle>,
+handle: *mut LibPamHandle,
 /// The last return value from the handle.
 last_return: Cell<Result<()>>,
 /// If set, the Conversation that this PAM handle owns.
 ///
 /// We have to hold on to this because the PAM specification doesn't
 /// that you pass in to `pam_start`, but OpenPAM uses the pointer itself,
 /// so you have to keep it in one place.
 conversation: Box<OwnedConversation<C>>,
 }
+impl<C: Conversation> fmt::Debug for LibPamTransaction<C> {
+fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+f.debug_struct(any::type_name::<Self>())
+.field("handle", &format!("{:p}", self.handle))
+.field("last_return", &self.last_return.get())
+.field("conversation", &format!("{:p}", self.conversation))
+.finish()
+}
+}
 #[derive(Debug, PartialEq)]
 pub struct TransactionBuilder {
 service_name: OsString,
 username: Option<OsString>,
 }
 self.username = Some(username.as_ref().into());
 self
 }
 /// Builds the PAM handle and starts the transaction.
-pub fn build(self, conv: impl Conversation) -> Result<LibPamTransaction<impl Conversation>> {
+pub fn build<C: Conversation>(self, conv: C) -> Result<LibPamTransaction<C>> {
 LibPamTransaction::start(self.service_name, self.username, conv)
 }
 }
 impl<C: Conversation> LibPamTransaction<C> {
 fn start(service_name: OsString, username: Option<OsString>, conversation: C) -> Result<Self> {
-let conv = Box::new(OwnedConversation::new(conversation));
+let mut conv = Box::new(OwnedConversation::new(conversation));
 let service_cstr = CString::new(service_name.as_bytes()).expect("null is forbidden");
 let username_cstr = memory::option_cstr_os(username.as_deref());
 let username_cstr = memory::prompt_ptr(username_cstr.as_deref());
 let mut handle: *mut libpam_sys::pam_handle = ptr::null_mut();
+let conv_ptr: *mut OwnedConversation<_> = conv.as_mut() as _;
 // SAFETY: We've set everything up properly to call `pam_start`.
 // The returned value will be a valid pointer provided the result is OK.
 let result = unsafe {
 libpam_sys::pam_start(
 service_cstr.as_ptr(),
 username_cstr,
-(conv.as_ref() as *const OwnedConversation<C>)
+conv_ptr.cast(),
-.cast_mut()
-.cast(),
 &mut handle,
 )
 };
 ErrorCode::result_from(result)?;
 let handle = NonNull::new(handle).ok_or(ErrorCode::BufferError)?;
 Ok(Self {
-handle: ManuallyDrop::new(LibPamHandle(handle)),
+handle: handle.as_ptr().cast(),
 last_return: Cell::new(Ok(())),
 conversation: conv,
 })
 }
 }
 /// Internal "end" function, which binary-ORs the status with `or_with`.
 fn end_internal(&mut self, or_with: i32) {
 let result = ErrorCode::result_to_c(self.last_return.get()) | or_with;
-unsafe { libpam_sys::pam_end(self.handle.raw_mut(), result) };
+unsafe { libpam_sys::pam_end(self.handle.cast(), result) };
 }
 }
 macro_rules! wrap {
 (fn $name:ident { $pam_func:ident }) => {
 fn $name(&mut self, flags: Flags) -> Result<()> {
-ErrorCode::result_from(unsafe { libpam_sys::$pam_func(self.0.as_mut(), flags.bits()) })
+ErrorCode::result_from(unsafe {
+libpam_sys::$pam_func((self as *mut Self).cast(), flags.bits())
+})
 }
 };
 }
 impl Transaction for LibPamHandle {
 }
 // TODO: pam_setcred - app
 //       pam_open_session - app
 //       pam_close_session - app
-//       pam_set/get_data - module
 impl<C: Conversation> Drop for LibPamTransaction<C> {
 /// Closes the PAM session on an owned PAM handle.
 ///
 /// This internally calls `pam_end` with the appropriate error code.
 macro_rules! delegate {
 // First have the kind that save the result after delegation.
 (fn $meth:ident(&self $(, $param:ident: $typ:ty)*) -> Result<$ret:ty>) => {
 fn $meth(&self $(, $param: $typ)*) -> Result<$ret> {
-let result = self.handle.$meth($($param),*);
+let result = unsafe { &*self.handle }.$meth($($param),*);
 self.last_return.set(split(&result));
 result
 }
 };
 (fn $meth:ident(&mut self $(, $param:ident: $typ:ty)*) -> Result<$ret:ty>) => {
 fn $meth(&mut self $(, $param: $typ)*) -> Result<$ret> {
-let result = self.handle.$meth($($param),*);
+let result = unsafe { &mut *self.handle }.$meth($($param),*);
 self.last_return.set(split(&result));
 result
 }
 };
 // Then have the kind that are just raw delegates
 (fn $meth:ident(&self $(, $param:ident: $typ:ty)*) -> $ret:ty) => {
 fn $meth(&self $(, $param: $typ)*) -> $ret {
-self.handle.$meth($($param),*)
+unsafe { &*self.handle }.$meth($($param),*)
 }
 };
 (fn $meth:ident(&mut self $(, $param:ident: $typ:ty)*) -> $ret:ty) => {
 fn $meth(&mut self $(, $param: $typ)*) -> $ret {
-self.handle.$meth($($param),*)
+unsafe { &mut *self.handle }.$meth($($param),*)
 }
 };
 // Then have item getters / setters
 (get = $get:ident$(, set = $set:ident)?) => {
 delegate!(fn $get(&self) -> Result<Option<OsString>>);
 /// a PAM handle created by another library.
 ///
 /// If [`Self::end`] is not called, this will always call `pam_end` reporting
 /// successful completion.
 #[repr(transparent)]
-pub struct LibPamHandle(NonNull<libpam_sys::pam_handle>);
+pub struct LibPamHandle(libpam_sys::pam_handle);
 impl LibPamHandle {
-/// Takes ownership of the pointer to the given PAM handle.
-///
-/// **Do not use this just to get a reference to a PAM handle.**
-///
-/// # Safety
-///
-/// - The pointer must point to a valid PAM handle.
-/// - The conversation associated with the handle must remain valid
-///   for as long as the handle is open.
-pub unsafe fn from_ptr(handle: NonNull<libpam_sys::pam_handle>) -> Self {
-Self(handle)
-}
 /// Ends the transaction, reporting `error_code` to cleanup callbacks.
 ///
 /// # References
 #[doc = linklist!(pam_end: adg, _std)]
 ///
 #[doc = guide!(adg: "adg-interface-by-app-expected.html#adg-pam_end")]
 #[doc = stdlinks!(3 pam_end)]
-pub fn end(self, result: Result<()>) {
+pub fn end(&mut self, result: Result<()>) {
-let mut me = ManuallyDrop::new(self);
+unsafe { libpam_sys::pam_end(self.inner_mut(), ErrorCode::result_to_c(result)) };
-unsafe { libpam_sys::pam_end(me.raw_mut(), ErrorCode::result_to_c(result)) };
 }
 #[cfg_attr(
 not(pam_impl = "LinuxPam"),
 doc = "Exactly equivalent to [`Self::end`], except on Linux-PAM."
 /// # References
 #[doc = linklist!(pam_end: adg, _std)]
 ///
 #[doc = guide!(adg: "adg-interface-by-app-expected.html#adg-pam_end")]
 #[doc = stdlinks!(3 pam_end)]
-pub fn end_silent(self, result: Result<()>) {
+pub fn end_silent(&mut self, result: Result<()>) {
-let mut me = ManuallyDrop::new(self);
 let result = ErrorCode::result_to_c(result);
 #[cfg(pam_impl = "LinuxPam")]
 let result = result | libpam_sys::PAM_DATA_SILENT;
 unsafe {
-libpam_sys::pam_end(me.raw_mut(), result);
+libpam_sys::pam_end(self.inner_mut(), result);
 }
-}
-/// Consumes this and gives you back the raw PAM handle.
-pub fn into_inner(self) -> NonNull<libpam_sys::pam_handle> {
-let me = ManuallyDrop::new(self);
-me.0
 }
 /// Gets a reference to the inner PAM handle.
-pub fn raw_ref(&self) -> &libpam_sys::pam_handle {
+pub fn inner(&self) -> &libpam_sys::pam_handle {
-unsafe { self.0.as_ref() }
+&self.0
 }
 /// Gets a mutable reference to the inner PAM handle.
-pub fn raw_mut(&mut self) -> &mut libpam_sys::pam_handle {
+pub fn inner_mut(&mut self) -> &mut libpam_sys::pam_handle {
-unsafe { self.0.as_mut() }
+&mut self.0
-}
-}
-impl Drop for LibPamHandle {
-fn drop(&mut self) {
-unsafe { libpam_sys::pam_end(self.0.as_mut(), 0) };
 }
 }
 impl Logger for LibPamHandle {
 fn log(&self, level: Level, loc: Location<'_>, entry: fmt::Arguments) {
 };
 _ = loc;
 // SAFETY: We're calling this function with a known value.
 #[cfg(pam_impl = "LinuxPam")]
 unsafe {
-libpam_sys::pam_syslog(
+libpam_sys::pam_syslog(self.inner(), level, b"%s\0".as_ptr().cast(), entry.as_ptr())
-self.raw_ref(),
-level,
-b"%s\0".as_ptr().cast(),
-entry.as_ptr(),
-)
 }
 #[cfg(pam_impl = "Sun")]
 unsafe {
 libpam_sys::__pam_log(level, b"%s\0".as_ptr().cast(), entry.as_ptr())
 }
 fn username(&mut self, prompt: Option<&OsStr>) -> Result<OsString> {
 let prompt = memory::option_cstr_os(prompt);
 let mut output: *const c_char = ptr::null();
 let ret = unsafe {
 libpam_sys::pam_get_user(
-self.raw_mut(),
+self.inner_mut(),
 &mut output,
 memory::prompt_ptr(prompt.as_deref()),
 )
 };
 ErrorCode::result_from(ret)?;
 // and corrupt its value's data.
 let full_key = module_data_key::<T>(key);
 let mut ptr: *const c_void = ptr::null();
 unsafe {
 ErrorCode::result_from(libpam_sys::pam_get_data(
-self.raw_ref(),
+self.inner(),
 full_key.as_ptr(),
 &mut ptr,
 ))
 .ok()?;
 fn set_module_data<T: 'static>(&mut self, key: &str, data: T) -> Result<()> {
 let full_key = module_data_key::<T>(key);
 let data = Box::new(data);
 ErrorCode::result_from(unsafe {
 libpam_sys::pam_set_data(
-self.raw_mut(),
+self.inner_mut(),
 full_key.as_ptr(),
 Box::into_raw(data).cast(),
 drop_module_data::<T>,
 )
 })
 let prompt = memory::option_cstr_os(prompt);
 let mut output: *const c_char = ptr::null();
 // SAFETY: We're calling this with known-good values.
 let res = unsafe {
 libpam_sys::pam_get_authtok(
-self.raw_mut(),
+self.inner_mut(),
 item_type.into(),
 &mut output,
 memory::prompt_ptr(prompt.as_deref()),
 )
 };
 // that you specify where you want the authtok to come from.
 // First we see if there's an authtok already set.
 let mut output: *mut c_char = ptr::null_mut();
 let result = unsafe {
 libpam_sys::__pam_get_authtok(
-self.raw_mut(),
+self.inner_mut(),
 libpam_sys::PAM_HANDLE,
 item_type.into(),
 ptr::null(),
 &mut output,
 )
 drop(output);
 let mut output: *mut c_char = ptr::null_mut();
 let prompt = memory::option_cstr_os(prompt);
 let result = unsafe {
 libpam_sys::__pam_get_authtok(
-self.raw_mut(),
+self.inner_mut(),
 libpam_sys::PAM_PROMPT,
 item_type.into(),
 memory::prompt_ptr(prompt.as_deref()),
 &mut output,
 )
 .ok_or(ErrorCode::ConversationError)
 }
 /// Gets the `PAM_CONV` item from the handle.
 fn conversation_item(&self) -> Result<&PamConv> {
-let output: *const PamConv = ptr::null_mut();
+let mut output: *const c_void = ptr::null();
 let result = unsafe {
-libpam_sys::pam_get_item(
+libpam_sys::pam_get_item(self.inner(), ItemType::Conversation.into(), &mut output)
-self.raw_ref(),
-ItemType::Conversation.into(),
-&mut output.cast(),
-)
 };
 ErrorCode::result_from(result)?;
+let output: *const PamConv = output.cast();
 // SAFETY: We got this result from PAM, and we're checking if it's null.
 unsafe { output.as_ref() }.ok_or(ErrorCode::ConversationError)
 }
 }

Mercurial > crates > nonstick

comparison src/libpam/handle.rs @ 163:a75a66cb4181