translate remaining "naked" user-facing strings

Author: squell

src/pam/converse.rs

@@ -2,6 +2,7 @@ use std::ffi::{c_int, c_void};
 use std::time::Duration;
 
 use crate::cutils::string_from_ptr;
+use crate::gettext::xlat;
 use crate::pam::rpassword::Hidden;
 use crate::system::signal::{self, SignalSet};
 
@@ -144,8 +145,9 @@ impl CLIConverser {
 impl Converser for CLIConverser {
     fn handle_normal_prompt(&self, msg: &str) -> PamResult<PamBuffer> {
         let (mut tty, _guard) = self.open()?;
+        let input_needed = xlat!("input needed");
         tty.read_input(
-            &format!("[{}: input needed] {msg} ", self.name),
+            &format!("[{}: {input_needed} {msg} ", self.name),
             None,
             Hidden::No,
         )

src/pam/mod.rs

@@ -7,6 +7,7 @@ use std::{
     time::Duration,
 };
 
+use crate::gettext::xlat;
 use crate::system::signal::{self, SignalSet};
 
 use converse::ConverserData;
@@ -80,7 +81,7 @@ impl PamContext {
             converser,
             converser_name: converser_name.to_owned(),
             no_interact,
-            auth_prompt: Some("authenticate".to_owned()),
+            auth_prompt: Some(xlat!("authenticate").to_owned()),
             error: None,
             panicked: false,
         }));

src/sudo/cli/mod.rs

@@ -207,7 +207,11 @@ impl TryFrom<SudoOptions> for SudoValidateOptions {
         let user = mem::take(&mut opts.user);
 
         if bell && stdin {
-            return Err("--bell conflicts with --stdin".into());
+            return Err(xlat!(
+                "{option1} conflicts with {option2}",
+                option1 = "--bell",
+                option2 = "--stdin"
+            ));
         }
 
         reject_all("--validate", opts)?;
@@ -268,13 +272,17 @@ impl TryFrom<SudoOptions> for SudoEditOptions {
         let positional_args = mem::take(&mut opts.positional_args);
 
         if bell && stdin {
-            return Err("--bell conflicts with --stdin".into());
+            return Err(xlat!(
+                "{option1} conflicts with {option2}",
+                option1 = "--bell",
+                option2 = "--stdin"
+            ));
         }
 
         reject_all("--edit", opts)?;
 
         if positional_args.is_empty() {
-            return Err("must specify at least one file path".into());
+            return Err(xlat!("must specify at least one file path").into());
         }
 
         Ok(Self {
@@ -336,15 +344,22 @@ impl TryFrom<SudoOptions> for SudoListOptions {
         let positional_args = mem::take(&mut opts.positional_args);
 
         if bell && stdin {
-            return Err("--bell conflicts with --stdin".into());
+            return Err(xlat!(
+                "{option1} conflicts with {option2}",
+                option1 = "--bell",
+                option2 = "--stdin"
+            ));
         }
 
         // when present, `-u` must be accompanied by a command
         let has_command = !positional_args.is_empty();
         let valid_user_flag = user.is_none() || has_command;
 
         if !valid_user_flag {
-            return Err("'--user' flag must be accompanied by a command".into());
+            return Err(xlat!(
+                "'{option}' flag must be accompanied by a command",
+                option = "--user"
+            ));
         }
 
         reject_all("--list", opts)?;
@@ -415,24 +430,34 @@ impl TryFrom<SudoOptions> for SudoRunOptions {
         let positional_args = mem::take(&mut opts.positional_args);
 
         if bell && stdin {
-            return Err("--bell conflicts with --stdin".into());
+            return Err(xlat!(
+                "{option1} conflicts with {option2}",
+                option1 = "--bell",
+                option2 = "--stdin"
+            ));
         }
 
         let context = match (login, shell, positional_args.is_empty()) {
             (true, false, _) => "--login",
             (false, true, _) => "--shell",
-            (false, false, false) => "command (positional argument)",
-
-            (true, true, _) => return Err("--login conflicts with --shell".into()),
+            (false, false, false) => xlat!("command (positional argument)"),
+
+            (true, true, _) => {
+                return Err(xlat!(
+                    "{option1} conflicts with {option2}",
+                    option1 = "--login",
+                    option2 = "--shell"
+                ))
+            }
             (false, false, true) => {
                 if cfg!(debug_assertions) {
                     // see `SudoOptions::validate`
                     panic!();
                 } else {
-                    return Err(
+                    return Err(xlat!(
                         "expected one of: --login, --shell, a command as a positional argument"
-                            .into(),
-                    );
+                    )
+                    .into());
                 }
             }
         };
@@ -586,7 +611,7 @@ impl SudoArg {
 
                         // assignment syntax is not accepted for shorthand arguments
                         if next == Some('=') {
-                            Err("invalid option '='")?;
+                            Err(xlat!("invalid option '='"))?;
                         }
                         if next.is_some() {
                             processed.push(SudoArg::Argument(flag, rest.to_string()));
@@ -596,7 +621,7 @@ impl SudoArg {
                             // short version of --help has no arguments
                             processed.push(SudoArg::Flag(flag));
                         } else {
-                            Err(xlat!("'-{option}' expects an argument", option = curr))?;
+                            Err(xlat!("'{option}' expects an argument", option = flag))?;
                         }
                         break;
                     } else {
@@ -639,7 +664,7 @@ impl SudoOptions {
             } else if self.reset_timestamp {
                 SudoAction::ResetTimestamp(self.try_into()?)
             } else {
-                return Err("expected one of these actions: --help, --version, --remove-timestamp, --validate, --list, --edit, --login, --shell, a command as a positional argument, --reset-timestamp".into());
+                return Err(xlat!("expected one of these actions: --help, --version, --remove-timestamp, --validate, --list, --edit, --login, --shell, a command as a positional argument, --reset-timestamp").into());
             }
         };
 
@@ -720,7 +745,7 @@ impl SudoOptions {
                         options.validate = true;
                     }
                     _option => {
-                        Err("invalid option provided")?;
+                        Err(xlat!("invalid option provided"))?;
                     }
                 },
                 SudoArg::Argument(option, value) => match option.as_str() {
@@ -749,7 +774,7 @@ impl SudoOptions {
                         options.user = Some(SudoString::from_cli_string(value));
                     }
                     _option => {
-                        Err("invalid option provided")?;
+                        Err(xlat!("invalid option provided"))?;
                     }
                 },
                 SudoArg::Environment(key, value) => {
@@ -828,7 +853,7 @@ fn ensure_is_absent(context: &str, thing: &dyn IsAbsent, name: &str) -> Result<(
 
 fn reject_all(context: &str, opts: SudoOptions) -> Result<(), String> {
     macro_rules! check_options {
-        ($($field:ident $(= $name:literal)?,)*) => {{
+        ($($field:ident $(= $name:expr)?,)*) => {{
             let SudoOptions { $($field),* } = opts;
 
             $(
@@ -846,7 +871,7 @@ fn reject_all(context: &str, opts: SudoOptions) -> Result<(), String> {
                 Cow::Borrowed(name)
             }
         }};
-        (@name $field:ident $name:literal) => {
+        (@name $field:ident $name:expr) => {
             $name
         };
     }
@@ -870,7 +895,7 @@ fn reject_all(context: &str, opts: SudoOptions) -> Result<(), String> {
         user,
         validate,
         version,
-        positional_args = "command",
-        env_var_list = "environment variable",
+        positional_args = xlat!("command"),
+        env_var_list = xlat!("environment variable"),
     )
 }

src/sudo/edit.rs

@@ -299,15 +299,18 @@ fn handle_child_inner(editor: &Path, mut files: Vec<ChildFileInfo<'_>>) -> Resul
 
         // If the file has been changed to be empty, ask the user what to do.
         if new_data.is_empty() && new_data != file.old_data {
+            // TRANSLATORS: the initial letters of 'yes' and 'no' responses, in that order
+            let answers = xlat!("yn").as_bytes().get(..2).unwrap_or(b"yn");
+
             match crate::visudo::ask_response(
                 xlat!(
                     "sudoedit: truncate {path} to zero? (y/n) [n] ",
                     path = file.path.display()
                 )
                 .as_bytes(),
-                b"yn",
+                answers,
             ) {
-                Ok(b'y') => {}
+                Ok(val) if val == answers[0] => {}
                 _ => {
                     user_info!("not overwriting {path}", path = file.path.display());
 

src/system/audit.rs

@@ -248,14 +248,17 @@ fn traversed_secure_open(path: impl AsRef<Path>, forbidden_user: &User) -> io::R
     let path = path.as_ref();
 
     let Some(file_name) = path.file_name() else {
-        return Err(io::Error::new(ErrorKind::InvalidInput, "invalid path"));
+        return Err(io::Error::new(
+            ErrorKind::InvalidInput,
+            xlat!("invalid path"),
+        ));
     };
 
     let mut components = path.parent().unwrap_or(Path::new("")).components();
     if components.next() != Some(Component::RootDir) {
         return Err(io::Error::new(
             ErrorKind::InvalidInput,
-            "path must be absolute",
+            xlat!("path must be absolute"),
         ));
     }
 
@@ -271,7 +274,7 @@ fn traversed_secure_open(path: impl AsRef<Path>, forbidden_user: &User) -> io::R
         {
             Err(io::Error::new(
                 ErrorKind::PermissionDenied,
-                "cannot open a file in a path writable by the user",
+                xlat!("cannot open a file in a path writable by the user"),
             ))
         } else {
             Ok(())
@@ -289,7 +292,7 @@ fn traversed_secure_open(path: impl AsRef<Path>, forbidden_user: &User) -> io::R
             _ => {
                 return Err(io::Error::new(
                     ErrorKind::InvalidInput,
-                    "error in provided path",
+                    xlat!("error in provided path"),
                 ))
             }
         };