crates/nonstick: src/conv.rs comparison

comparison src/conv.rs @ 77:351bdc13005e

Update the libpam module to work with the new structure.

author	Paul Fisher <paul@pfish.zone>
date	Sun, 08 Jun 2025 01:03:46 -0400
parents	e58d24849e82
children	002adfb98c5c

comparison

equal deleted inserted replaced

-:e58d24849e82
+:351bdc13005e
 ///
 /// The data within each enum value is the prompt (or other information)
 /// that will be presented to the user.
 #[non_exhaustive]
 pub enum Message<'a> {
-MaskedPrompt(&'a MaskedPrompt<'a>),
+Prompt(&'a QAndA<'a>),
-Prompt(&'a Prompt<'a>),
+MaskedPrompt(&'a MaskedQAndA<'a>),
-RadioPrompt(&'a RadioPrompt<'a>),
+RadioPrompt(&'a RadioQAndA<'a>),
-BinaryPrompt(&'a BinaryPrompt<'a>),
+BinaryPrompt(&'a BinaryQAndA<'a>),
-InfoMsg(&'a InfoMsg<'a>),
+Error(&'a ErrorMsg<'a>),
-ErrorMsg(&'a ErrorMsg<'a>),
+Info(&'a InfoMsg<'a>),
 }
 impl Message<'_> {
 /// Sets an error answer on this question, without having to inspect it.
 ///
 /// use nonstick::conv::{Message, QAndA};
 /// use nonstick::ErrorCode;
 ///
 /// fn cant_respond(message: Message) {
 ///     match message {
-///         Message::InfoMsg(i) => {
+///         Message::Info(i) => {
 ///             eprintln!("fyi, {}", i.question());
 ///             i.set_answer(Ok(()))
 ///         }
-///         Message::ErrorMsg(e) => {
+///         Message::Error(e) => {
 ///             eprintln!("ERROR: {}", e.question());
 ///             e.set_answer(Ok(()))
 ///         }
 ///         // We can't answer any questions.
 ///         other => other.set_error(ErrorCode::ConversationError),
 ///     }
 /// }
 pub fn set_error(&self, err: ErrorCode) {
-match self {
+match *self {
+Message::Prompt(m) => m.set_answer(Err(err)),
 Message::MaskedPrompt(m) => m.set_answer(Err(err)),
-Message::Prompt(m) => m.set_answer(Err(err)),
 Message::RadioPrompt(m) => m.set_answer(Err(err)),
 Message::BinaryPrompt(m) => m.set_answer(Err(err)),
-Message::InfoMsg(m) => m.set_answer(Err(err)),
+Message::Error(m) => m.set_answer(Err(err)),
-Message::ErrorMsg(m) => m.set_answer(Err(err)),
+Message::Info(m) => m.set_answer(Err(err)),
 }
 }
-}
-/// A question-and-answer pair that can be communicated in a [`Conversation`].
-///
-/// The asking side creates a `QAndA`, then converts it to a [`Message`]
-/// and sends it via a [`Conversation`]. The Conversation then retrieves
-/// the answer to the question (if needed) and sets the response.
-/// Once control returns to the asker, the asker gets the answer from this
-/// `QAndA` and uses it however it wants.
-///
-/// For a more detailed explanation of how this works,
-/// see [`Conversation::communicate`].
-pub trait QAndA<'a> {
-/// The type of the content of the question.
-type Question: Copy;
-/// The type of the answer to the question.
-type Answer;
-/// Converts this Q-and-A pair into a [`Message`] for the [`Conversation`].
-fn message(&self) -> Message;
-/// The contents of the question being asked.
-///
-/// For instance, this might say `"Username:"` to prompt the user
-/// for their name.
-fn question(&self) -> Self::Question;
-/// Sets the answer to the question.
-///
-/// The [`Conversation`] implementation calls this to set the answer.
-/// The conversation should *always call this function*, even for messages
-/// that don't have "an answer" (like error or info messages).
-fn set_answer(&self, answer: Result<Self::Answer>);
-/// Gets the answer to the question.
-fn answer(self) -> Result<Self::Answer>;
 }
 macro_rules! q_and_a {
-($name:ident<'a, Q=$qt:ty, A=$at:ty>, $($doc:literal)*) => {
+($name:ident<'a, Q=$qt:ty, A=$at:ty>, $val:path, $($doc:literal)*) => {
 $(
 #[doc = $doc]
 )*
 pub struct $name<'a> {
 q: $qt,
 a: Cell<Result<$at>>,
 }
-impl<'a> QAndA<'a> for $name<'a> {
+impl<'a> $name<'a> {
-type Question = $qt;
+/// Converts this Q&A into a [`Message`] for the [`Conversation`].
-type Answer = $at;
+pub fn message(&self) -> Message {
+$val(self)
-fn question(&self) -> Self::Question {
+}
+/// The contents of the question being asked.
+///
+/// For instance, this might say `"Username:"` to prompt the user
+/// for their name, or the text of an error message.
+pub fn question(&self) -> $qt {
 self.q
 }
-fn set_answer(&self, answer: Result<Self::Answer>) {
+/// Sets the answer to the question.
+///
+/// The [`Conversation`] implementation calls this to set the answer.
+/// The conversation should *always call this function*,
+/// even for Q&A messages that don't have "an answer"
+/// (like error or info messages).
+pub fn set_answer(&self, answer: Result<$at>) {
 self.a.set(answer)
 }
-fn answer(self) -> Result<Self::Answer> {
+/// Gets the answer to the question.
+pub fn answer(self) -> Result<$at> {
 self.a.into_inner()
-}
-fn message(&self) -> Message {
-Message::$name(self)
 }
 }
 };
 }
 macro_rules! ask {
 ($t:ident) => {
 impl<'a> $t<'a> {
 #[doc = concat!("Creates a `", stringify!($t), "` to be sent to the user.")]
-fn ask(question: &'a str) -> Self {
+pub fn new(question: &'a str) -> Self {
 Self {
 q: question,
 a: Cell::new(Err(ErrorCode::ConversationError)),
 }
 }
 }
 };
 }
 q_and_a!(
-MaskedPrompt<'a, Q=&'a str, A=SecureString>,
+MaskedQAndA<'a, Q=&'a str, A=SecureString>,
-"Asks the user for data and does not echo it back while being entered."
+Message::MaskedPrompt,
+"A Q&A that asks the user for text and does not show it while typing."
 ""
 "In other words, a password entry prompt."
 );
-ask!(MaskedPrompt);
+ask!(MaskedQAndA);
 q_and_a!(
-Prompt<'a, Q=&'a str, A=String>,
+QAndA<'a, Q=&'a str, A=String>,
-"Asks the user for data."
+Message::Prompt,
+"A standard Q&A prompt that asks the user for text."
 ""
 "This is the normal \"ask a person a question\" prompt."
 "When the user types, their input will be shown to them."
 "It can be used for things like usernames."
 );
-ask!(Prompt);
+ask!(QAndA);
 q_and_a!(
-RadioPrompt<'a, Q=&'a str, A=String>,
+RadioQAndA<'a, Q=&'a str, A=String>,
-"Asks the user for \"radio button\"–style data. (Linux-PAM extension)"
+Message::RadioPrompt,
+"A Q&A for \"radio button\"–style data. (Linux-PAM extension)"
 ""
 "This message type is theoretically useful for \"yes/no/maybe\""
 "questions, but nowhere in the documentation is it specified"
 "what the format of the answer will be, or how this should be shown."
 );
-ask!(RadioPrompt);
+ask!(RadioQAndA);
 q_and_a!(
-BinaryPrompt<'a, Q=BinaryQuestion<'a>, A=BinaryData>,
+BinaryQAndA<'a, Q=BorrowedBinaryData<'a>, A=BinaryData>,
+Message::BinaryPrompt,
 "Asks for binary data. (Linux-PAM extension)"
 ""
 "This sends a binary message to the client application."
 "It can be used to communicate with non-human logins,"
 "or to enable things like security keys."
 ""
 "The `data_type` tag is a value that is simply passed through"
 "to the application. PAM does not define any meaning for it."
 );
-impl<'a> BinaryPrompt<'a> {
+impl<'a> BinaryQAndA<'a> {
 /// Creates a prompt for the given binary data.
 ///
 /// The `data_type` is a tag you can use for communication between
 /// the module and the application. Its meaning is undefined by PAM.
-fn ask(data: &'a [u8], data_type: u8) -> Self {
+pub fn new(data: &'a [u8], data_type: u8) -> Self {
+BorrowedBinaryData { data, data_type }.into()
+}
+}
+impl<'a> From<BorrowedBinaryData<'a>> for BinaryQAndA<'a> {
+fn from(q: BorrowedBinaryData<'a>) -> Self {
 Self {
-q: BinaryQuestion { data, data_type },
+q,
 a: Cell::new(Err(ErrorCode::ConversationError)),
 }
 }
 }
-/// The contents of a question requesting binary data.
+impl<'a> From<&'a BinaryData> for BinaryQAndA<'a> {
-///
+fn from(src: &'a BinaryData) -> Self {
-/// A borrowed version of [`BinaryData`].
+BorrowedBinaryData::from(src).into()
-#[derive(Copy, Clone, Debug)]
+}
-pub struct BinaryQuestion<'a> {
+}
+/// A version of [`BinaryData`] where the `data` is borrowed.
+#[derive(Copy, Clone, Debug, Default)]
+pub struct BorrowedBinaryData<'a> {
 data: &'a [u8],
 data_type: u8,
 }
-impl BinaryQuestion<'_> {
+impl<'a> BorrowedBinaryData<'a> {
+/// Creates a new BinaryQuestion as a view over the given data.
+pub fn new(data: &'a [u8], data_type: u8) -> Self {
+Self { data, data_type }
+}
 /// Gets the data of this question.
 pub fn data(&self) -> &[u8] {
 self.data
 }
 pub fn data_type(&self) -> u8 {
 self.data_type
 }
 }
+impl<'a> From<&'a BinaryData> for BorrowedBinaryData<'a> {
+fn from(value: &'a BinaryData) -> Self {
+Self::new(&value.data, value.data_type)
+}
+}
 /// Owned binary data.
 ///
-/// For borrowed data, see [`BinaryQuestion`].
+/// For borrowed data, see [`BorrowedBinaryData`].
 /// You can take ownership of the stored data with `.into::<Vec<u8>>()`.
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Default, PartialEq)]
 pub struct BinaryData {
 data: Vec<u8>,
 data_type: u8,
 }
 pub fn data_type(&self) -> u8 {
 self.data_type
 }
 }
+impl<'a> From<BorrowedBinaryData<'a>> for BinaryData {
+fn from(value: BorrowedBinaryData) -> Self {
+Self {
+data: value.data.to_vec(),
+data_type: value.data_type,
+}
+}
+}
 impl From<BinaryData> for Vec<u8> {
 /// Takes ownership of the data stored herein.
 fn from(value: BinaryData) -> Self {
 value.data
 }
 }
 q_and_a!(
 InfoMsg<'a, Q = &'a str, A = ()>,
+Message::Info,
 "A message containing information to be passed to the user."
 ""
 "While this does not have an answer, [`Conversation`] implementations"
 "should still call [`set_answer`][`QAndA::set_answer`] to verify that"
 "the message has been displayed (or actively discarded)."
 );
 impl<'a> InfoMsg<'a> {
 /// Creates an informational message to send to the user.
-fn new(message: &'a str) -> Self {
+pub fn new(message: &'a str) -> Self {
 Self {
 q: message,
 a: Cell::new(Err(ErrorCode::ConversationError)),
 }
 }
 }
 q_and_a!(
 ErrorMsg<'a, Q = &'a str, A = ()>,
+Message::Error,
 "An error message to be passed to the user."
 ""
 "While this does not have an answer, [`Conversation`] implementations"
 "should still call [`set_answer`][`QAndA::set_answer`] to verify that"
 "the message has been displayed (or actively discarded)."
 );
 impl<'a> ErrorMsg<'a> {
 /// Creates an error message to send to the user.
-fn new(message: &'a str) -> Self {
+pub fn new(message: &'a str) -> Self {
 Self {
 q: message,
 a: Cell::new(Err(ErrorCode::ConversationError)),
 }
 }
 /// Requests binary data from the user (a Linux-PAM extension).
 fn binary_prompt(&mut self, data: &[u8], data_type: u8) -> Result<BinaryData>;
 }
 macro_rules! conv_fn {
-($fn_name:ident($($param:ident: $pt:ty),+) -> $resp_type:ty { $ask:path }) => {
+($fn_name:ident($($param:ident: $pt:ty),+) -> $resp_type:ty { $msg:ty }) => {
 fn $fn_name(&mut self, $($param: $pt),*) -> Result<$resp_type> {
-let prompt = $ask($($param),*);
+let prompt = <$msg>::new($($param),*);
 self.communicate(&[prompt.message()]);
 prompt.answer()
 }
 };
-($fn_name:ident($($param:ident: $pt:ty),+) { $ask:path }) => {
+($fn_name:ident($($param:ident: $pt:ty),+) { $msg:ty }) => {
 fn $fn_name(&mut self, $($param: $pt),*) {
-self.communicate(&[$ask($($param),*).message()]);
+self.communicate(&[<$msg>::new($($param),*).message()]);
 }
 };
 }
 impl<C: Conversation> SimpleConversation for C {
-conv_fn!(prompt(message: &str) -> String { Prompt::ask });
+conv_fn!(prompt(message: &str) -> String { QAndA });
-conv_fn!(masked_prompt(message: &str) -> SecureString { MaskedPrompt::ask });
+conv_fn!(masked_prompt(message: &str) -> SecureString { MaskedQAndA } );
-conv_fn!(radio_prompt(message: &str) -> String { RadioPrompt::ask });
+conv_fn!(radio_prompt(message: &str) -> String { RadioQAndA });
-conv_fn!(error_msg(message: &str) { ErrorMsg::new });
+conv_fn!(error_msg(message: &str) { ErrorMsg });
-conv_fn!(info_msg(message: &str) { InfoMsg::new });
+conv_fn!(info_msg(message: &str) { InfoMsg });
-conv_fn!(binary_prompt(data: &[u8], data_type: u8) -> BinaryData { BinaryPrompt::ask });
+conv_fn!(binary_prompt(data: &[u8], data_type: u8) -> BinaryData { BinaryQAndA });
 }
 /// A [`Conversation`] which asks the questions one at a time.
 ///
 /// This is automatically created by [`SimpleConversation::as_conversation`].
 prompt.set_answer(self.0.masked_prompt(prompt.question()))
 }
 Message::RadioPrompt(prompt) => {
 prompt.set_answer(self.0.radio_prompt(prompt.question()))
 }
-Message::InfoMsg(prompt) => {
+Message::Info(prompt) => {
 self.0.info_msg(prompt.question());
 prompt.set_answer(Ok(()))
 }
-Message::ErrorMsg(prompt) => {
+Message::Error(prompt) => {
 self.0.error_msg(prompt.question());
 prompt.set_answer(Ok(()))
 }
 Message::BinaryPrompt(prompt) => {
 let q = prompt.question();
 }
 #[cfg(test)]
 mod tests {
 use super::{
-BinaryPrompt, Conversation, ErrorMsg, InfoMsg, MaskedPrompt, Message, Prompt, QAndA,
+BinaryQAndA, Conversation, ErrorMsg, InfoMsg, MaskedQAndA, Message, QAndA,
-RadioPrompt, Result, SecureString, SimpleConversation,
+RadioQAndA, Result, SecureString, SimpleConversation,
 };
 use crate::constants::ErrorCode;
 use crate::BinaryData;
 #[test]
 }
 }
 let mut tester = DemuxTester::default();
-let what = Prompt::ask("what");
+let what = QAndA::new("what");
-let pass = MaskedPrompt::ask("reveal");
+let pass = MaskedQAndA::new("reveal");
 let err = ErrorMsg::new("whoopsie");
 let info = InfoMsg::new("did you know");
-let has_err = Prompt::ask("give_err");
+let has_err = QAndA::new("give_err");
 let mut conv = tester.as_conversation();
 // Basic tests.
 // Test the Linux extensions separately.
 let mut conv = tester.as_conversation();
-let radio = RadioPrompt::ask("channel?");
+let radio = RadioQAndA::new("channel?");
-let bin = BinaryPrompt::ask(&[10, 9, 8], 66);
+let bin = BinaryQAndA::new(&[10, 9, 8], 66);
 conv.communicate(&[radio.message(), bin.message()]);
 assert_eq!("zero", radio.answer().unwrap());
 assert_eq!(BinaryData::new(vec![5, 5, 5], 5), bin.answer().unwrap());
 }
 impl Conversation for MuxTester {
 fn communicate(&mut self, messages: &[Message]) {
 if let [msg] = messages {
 match *msg {
-Message::InfoMsg(info) => {
+Message::Info(info) => {
 assert_eq!("let me tell you", info.question());
 info.set_answer(Ok(()))
 }
-Message::ErrorMsg(error) => {
+Message::Error(error) => {
 assert_eq!("oh no", error.question());
 error.set_answer(Ok(()))
 }
 Message::Prompt(prompt) => prompt.set_answer(match prompt.question() {
 "should_err" => Err(ErrorCode::PermissionDenied),

Mercurial > crates > nonstick

comparison src/conv.rs @ 77:351bdc13005e