Restore error recovery behavior in rm, rmdir, etc.

These tools continue on error. This patch uses `Result` and the
`and` method to collect `Err` values.

cksum/cksum.rs

@@ -119,15 +119,16 @@ pub fn uumain(args: Vec<String>) -> int {
         return 0;
     }
 
+    let mut exit_code = 0;
     for fname in files.iter() {
         match cksum(fname.as_slice()) {
             Ok((crc, size)) => println!("{} {} {}", crc, size, fname),
             Err(err) => {
                 show_error!("'{}' {}", fname, err);
-                return 2;
+                exit_code = 2;
             }
         }
     }
 
-    return 0;
+    return exit_code;
 }

mkdir/mkdir.rs

@@ -101,6 +101,8 @@ fn print_help(opts: &[getopts::OptGroup]) {
  * Create the list of new directories
  */
 fn exec(dirs: Vec<String>, mk_parents: bool, mode: FilePermission, verbose: bool) -> Result<(), int> {
+    let mut result = Ok(());
+
     let mut parent_dirs = Vec::new();
     if mk_parents {
         for dir in dirs.iter() {
@@ -121,7 +123,7 @@ fn exec(dirs: Vec<String>, mk_parents: bool, mode: FilePermission, verbose: bool
     if !parent_dirs.is_empty() {
         match exec(parent_dirs, mk_parents, mode, verbose) {
             Ok(()) => ( /* keep going */ ),
-            Err(e) => return Err(e)
+            Err(e) => result = Err(e)
         }
     }
 
@@ -145,11 +147,11 @@ fn exec(dirs: Vec<String>, mk_parents: bool, mode: FilePermission, verbose: bool
                     format!("directory '{}' already exists", *dir)
                 };
             show_error!("{}", error_msg);
-            return Err(1);
+            result = Err(1)
         }
     }
 
-    return Ok(());
+    return result;
 }
 
 /**

rm/rm.rs

@@ -81,7 +81,7 @@ pub fn uumain(args: Vec<String>) -> int {
     } else if matches.free.is_empty() {
         show_error!("missing an argument");
         show_error!("for help, try '{0:s} --help'", program);
-        return 0;
+        return 1;
     } else {
         let force = matches.opt_present("force");
         let interactive =
@@ -129,6 +129,8 @@ pub fn uumain(args: Vec<String>) -> int {
 
 // TODO: implement one-file-system
 fn remove(files: Vec<String>, force: bool, interactive: InteractiveMode, one_fs: bool, preserve_root: bool, recursive: bool, dir: bool, verbose: bool) -> Result<(), int> {
+    let mut r = Ok(());
+
     for filename in files.iter() {
         let filename = filename.as_slice();
         let file = Path::new(filename);
@@ -141,43 +143,31 @@ fn remove(files: Vec<String>, force: bool, interactive: InteractiveMode, one_fs:
                             crash!(1, "{}", f.to_str());
                         }
                     };
-                    match remove(walk_dir.map(|x| x.as_str().unwrap().to_string()).collect(), force, interactive, one_fs, preserve_root, recursive, dir, verbose) {
+                    r = remove(walk_dir.map(|x| x.as_str().unwrap().to_string()).collect(), force, interactive, one_fs, preserve_root, recursive, dir, verbose).and(r);
-                        Ok(()) => ( /* pass */ ),
+                    r = remove_dir(&file, filename, interactive, verbose).and(r);
-                        Err(e) => return Err(e)
-                    }
-                    match remove_dir(&file, filename, interactive, verbose) {
-                        Ok(()) => ( /* pass */ ),
-                        Err(e) => return Err(e)
-                    }
                 } else if dir && (filename != "/" || !preserve_root) {
-                    match remove_dir(&file, filename, interactive, verbose) {
+                    r = remove_dir(&file, filename, interactive, verbose).and(r);
-                        Ok(()) => ( /* pass */ ),
-                        Err(e) => return Err(e)
-                    }
                 } else {
                     if recursive {
                         show_error!("could not remove directory '{}'",
                                        filename);
-                        return Err(1);
+                        r = Err(1);
                     } else {
                         show_error!("could not remove directory '{}' (did you mean to pass '-r'?)",
                                     filename);
-                        return Err(1);
+                        r = Err(1);
                     }
                 }
             } else {
-                match remove_file(&file, filename.as_slice(), interactive, verbose) {
+                r = remove_file(&file, filename.as_slice(), interactive, verbose).and(r);
-                    Ok(()) => ( /* pass */ ),
-                    Err(e) => return Err(e)
-                }
             }
         } else if !force {
             show_error!("no such file or directory '{}'", filename);
-            return Err(1);
+            r = Err(1);
         }
     }
 
-    return Ok(());
+    return r;
 }
 
 fn remove_dir(path: &Path, name: &str, interactive: InteractiveMode, verbose: bool) -> Result<(), int> {

rmdir/rmdir.rs

@@ -70,25 +70,24 @@ pub fn uumain(args: Vec<String>) -> int {
 }
 
 fn remove(dirs: Vec<String>, ignore: bool, parents: bool, verbose: bool) -> Result<(), int>{
+    let mut r = Ok(());
+
     for dir in dirs.iter() {
         let path = Path::new(dir.as_slice());
         if path.exists() {
             if path.is_dir() {
-                match remove_dir(&path, dir.as_slice(), ignore, parents, verbose) {
+                r = remove_dir(&path, dir.as_slice(), ignore, parents, verbose).and(r);
-                    Ok(()) => ( /* pass */ ),
-                    Err(e) => return Err(e)
-                }
             } else {
                 show_error!("failed to remove '{}' (file)", *dir);
-                return Err(1);
+                r = Err(1);
             }
         } else {
             show_error!("no such file or directory '{}'", *dir);
-            return Err(1);
+            r = Err(1);
         }
     }
 
-    return Ok(());
+    return r;
 }
 
 fn remove_dir(path: &Path, dir: &str, ignore: bool, parents: bool, verbose: bool) -> Result<(), int> {
@@ -99,6 +98,9 @@ fn remove_dir(path: &Path, dir: &str, ignore: bool, parents: bool, verbose: bool
             return Err(1);
         }
     };
+
+    let mut r = Ok(());
+    
     if walk_dir.next() == None {
         match fs::rmdir(path) {
             Ok(_) => {
@@ -108,23 +110,20 @@ fn remove_dir(path: &Path, dir: &str, ignore: bool, parents: bool, verbose: bool
                 if parents {
                     let dirname = path.dirname_str().unwrap();
                     if dirname != "." {
-                        match remove_dir(&Path::new(dirname), dirname, ignore, parents, verbose) {
+                        r = remove_dir(&Path::new(dirname), dirname, ignore, parents, verbose).and(r);
-                            Ok(()) => ( /* pass */ ),
-                            Err(e) => return Err(e)
-                        }
                     }
                 }
             }
             Err(f) => {
                 show_error!("{}", f.to_str());
-                return Err(1);
+                r = Err(1);
             }
         }
     } else if !ignore {
         show_error!("Failed to remove directory '{}' (non-empty)", dir);
-        return Err(1);
+        r = Err(1);
     }
 
-    return Ok(());
+    return r;
 }