Merge pull request #13 from UsernameSwift/main

Added a shell chooser

src/args.rs

@@ -228,6 +228,10 @@ pub struct NewUserArgs {
     /// When not providing a password openssl jumps into an interactive masked input mode allowing you to hide your password
     /// from the terminal history.
     pub password: String,
+
+    /// The shell to use for the user. The current options are bash, csh, fish, tcsh, and zsh.
+    /// If a shell is not specified or unknown, it defaults to fish.
+    pub shell: String,
 }
 
 #[derive(Debug, ArgEnum, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Serialize, Deserialize)]

src/functions/unakite.rs

@@ -127,6 +127,7 @@ pub fn setup_unakite(root: &str, oldroot: &str, efi: bool, efidir: &str, bootdev
         true,
         "Cp7oN04ZY0PsA", // unakite
         false,
+        "/bin/bash",
     );
     exec_eval(
         exec(

src/functions/users.rs

@@ -2,7 +2,8 @@ use crate::internal::exec::*;
 use crate::internal::*;
 use std::process::Command;
 
-pub fn new_user(username: &str, hasroot: bool, password: &str, do_hash_pass: bool) {
+pub fn new_user(username: &str, hasroot: bool, password: &str, do_hash_pass: bool, shell: &str) {
+    let shell: &str = shell;
     if do_hash_pass {
         let hashed_pass = &*hash_pass(password).stdout;
         let _password = match std::str::from_utf8(hashed_pass) {
@@ -10,13 +11,40 @@ pub fn new_user(username: &str, hasroot: bool, password: &str, do_hash_pass: boo
             Err(e) => panic!("Failed to hash password, invalid UTF-8 sequence {}", e),
         };
     }
+    let shell_to_install = match shell {
+        "bash" => "bash",
+        "csh" => "tcsh",
+        "fish" => "fish",
+        "tcsh" => "tcsh",
+        "zsh" => "zsh",
+        &_ => "bash",
+    };
+    exec_eval(
+        exec_chroot(
+            "bash",
+            vec![
+                String::from("pacman -S "),
+                String::from(shell_to_install),
+                String::from("--noconfirm"),
+            ],
+        ),
+        format!("installed {shell:?}").as_str(),
+    );
+    let shell_path = match shell {
+        "bash" => "/bin/bash",
+        "csh" => "/usr/bin/csh",
+        "fish" => "/usr/bin/fish",
+        "tcsh" => "/usr/bin/tcsh",
+        "zsh" => "/usr/bin/zsh",
+        &_ => "/usr/bin/fish",
+    };
     exec_eval(
         exec_chroot(
             "useradd",
             vec![
                 String::from("-m"),
                 String::from("-s"),
-                String::from("/bin/bash"),
+                String::from(shell_path),
                 String::from("-p"),
                 String::from(password).replace('\n', ""),
                 String::from(username),
@@ -67,3 +95,4 @@ pub fn root_pass(root_pass: &str) {
         "set root password",
     );
 }
+

src/internal/config.rs

@@ -53,6 +53,7 @@ struct Users {
     name: String,
     password: String,
     hasroot: bool,
+    shell: String,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -138,11 +139,13 @@ pub fn read_config(configpath: PathBuf) {
         log::info!("Creating user : {}", config.users[i].name);
         log::info!("Setting use password : {}", config.users[i].password);
         log::info!("Enabling root for user : {}", config.users[i].hasroot);
+        log::info!("Setting user shell : {}", config.users[i].shell);
         users::new_user(
             config.users[i].name.as_str(),
             config.users[i].hasroot,
             config.users[i].password.as_str(),
             false,
+            config.users[i].shell.as_str(),
         );
         println!("---------");
     }

src/main.rs

@@ -53,7 +53,7 @@ fn main() {
         }
         Command::Users { subcommand } => match subcommand {
             UsersSubcommand::NewUser(args) => {
-                users::new_user(&args.username, args.hasroot, &args.password, true);
+                users::new_user(&args.username, args.hasroot, &args.password, true, &args.shell);
             }
             UsersSubcommand::RootPass { password } => {
                 users::root_pass(&password);