[uuencode, uudecode]: fix uuencode, uudecode and write their tests

xform/Cargo.toml

@@ -10,7 +10,6 @@ repository = "https://github.com/rustcoreutils/posixutils-rs.git"
 plib = { path = "../plib" }
 clap.workspace = true
 gettext-rs.workspace = true
-uuencode = "0.1"
 base64 = "0.21"
 
 [[bin]]

xform/src/uudecode.rs

@@ -9,16 +9,22 @@
 
 extern crate clap;
 extern crate plib;
-extern crate uuencode;
 
 use base64::prelude::*;
 use clap::Parser;
 use gettextrs::{bind_textdomain_codeset, textdomain};
 use plib::PROJECT_NAME;
-use std::fs::OpenOptions;
-use std::io::{self, Error, ErrorKind, Read, Write};
+use std::fs::{remove_file, File};
+use std::io::{self, Error, Read, Write};
+use std::os::unix::fs::PermissionsExt;
 use std::path::PathBuf;
 
+macro_rules! reduce {
+    ($e : expr) => {
+        $e - 0x20
+    };
+}
+
 /// uudecode - decode a binary file
 #[derive(Parser, Debug)]
 #[command(author, version, about, long_about)]
@@ -31,52 +37,140 @@ struct Args {
     file: Option<PathBuf>,
 }
 
-fn write_file(pathname: &PathBuf, bindata: &[u8]) -> io::Result<()> {
-    let f_res = OpenOptions::new()
-        .read(false)
-        .write(true)
-        .create(true)
-        .truncate(true)
-        .open(pathname);
-
-    match f_res {
-        Err(e) => {
-            eprintln!("{}: {}", pathname.display(), e);
-            return Err(e);
+#[derive(Debug)]
+enum DecodingType {
+    Historical,
+
+    Base64,
+}
+
+#[derive(Debug)]
+struct Header {
+    dec_type: DecodingType,
+
+    lower_perm_bits: u32,
+
+    out: PathBuf,
+}
+
+impl Header {
+    fn parse(line: &str) -> Self {
+        // split with spaces
+        let split: Vec<&str> = line.split(' ').collect();
+        let dec_type = if split[0] == "begin" {
+            DecodingType::Historical
+        } else if split[0] == "begin-base64" {
+            DecodingType::Base64
+        } else {
+            panic!("Invalid encoding type");
+        };
+
+        let lower_perm_bits = u32::from_str_radix(split[1], 8).expect("Invalid permission value");
+        let out = PathBuf::from(split[2]);
+
+        Self {
+            dec_type,
+            lower_perm_bits,
+            out,
         }
-        Ok(mut file) => file.write_all(bindata),
     }
 }
 
+fn decode_historical_line(line: &str) -> Vec<u8> {
+    let mut out = Vec::new();
+
+    for chunk in line.as_bytes().chunks(4) {
+        let chunk = chunk.to_vec();
+
+        let out_chunk = [
+            reduce!(chunk[0]) << 2 | (reduce!(chunk[1])) >> 4,
+            reduce!(chunk[1]) << 4 | reduce!(chunk[2]) >> 2,
+            reduce!(chunk[2]) << 6 | reduce!(chunk[3]),
+        ];
+
+        out.extend_from_slice(&out_chunk);
+    }
+
+    out
+}
+
+fn decode_base64_line(line: &str) -> io::Result<Vec<u8>> {
+    BASE64_STANDARD
+        .decode(&line)
+        .map_err(|_| Error::from(io::ErrorKind::InvalidInput))
+}
+
 fn decode_file(args: &Args) -> io::Result<()> {
-    let mut file = plib::io::input_stream_opt(&args.file)?;
-
-    // read entire file into memory.
-    // ugly but necessary due to uudecode crate implementation.
-    let mut buffer = String::new();
-    file.read_to_string(&mut buffer)?;
-
-    // attempt base64 decode
-    let b64_res = BASE64_STANDARD.decode(buffer.as_bytes());
-    match b64_res {
-        // fall through to uudecode format
-        Err(_e) => {}
-
-        // decode succeeded. exit here.
-        Ok(bindata) => match &args.outfile {
-            None => return write_file(&PathBuf::from("bindata.out"), &bindata[..]),
-            Some(outfn) => return write_file(outfn, &bindata[..]),
-        },
+    let mut buf: Vec<u8> = Vec::new();
+    let mut out: Vec<u8> = Vec::new();
+
+    let file_p = args
+        .file
+        .as_ref()
+        .unwrap_or(&PathBuf::from("/dev/stdin"))
+        .clone();
+
+    if file_p == PathBuf::from("/dev/stdin") {
+        io::stdin().lock().read_to_end(&mut buf)?;
+    } else {
+        let mut file = File::open(&file_p)?;
+        file.read_to_end(&mut buf)?;
+    }
+
+    let buf = String::from_utf8(buf).unwrap();
+    let mut lines = buf.lines();
+    let header = Header::parse(lines.next().expect("No header line"));
+
+    match header.dec_type {
+        DecodingType::Historical => {
+            while let Some(line) = lines.next() {
+                let line = line.replace("`", " ");
+                if line.len() == 1 && line == " " {
+                    let end_line = lines.next().expect("No end line");
+                    if end_line == "end" || end_line == "end\r" {
+                        break;
+                    } else {
+                        panic!("Invalid ending")
+                    }
+                }
+
+                let len = (line[..1].as_bytes()[0] - 32) as usize;
+                let mut dec_out = decode_historical_line(&line[1..]);
+                dec_out.truncate(len);
+                out.extend_from_slice(&dec_out);
+            }
+        }
+
+        DecodingType::Base64 => {
+            while let Some(line) = lines.next() {
+                if line == "====" || line == "====\n" {
+                    break;
+                }
+                out.extend_from_slice(&decode_base64_line(line)?);
+            }
+        }
     }
 
-    // attempt to decode using uudecode format
-    match uuencode::uudecode(&buffer) {
-        None => return Err(Error::new(ErrorKind::Other, "invalid input data")),
-        Some((bindata, filename)) => match &args.outfile {
-            None => write_file(&PathBuf::from(filename), &bindata[..]),
-            Some(outfn) => write_file(outfn, &bindata[..]),
-        },
+    let out_path = args.outfile.as_ref().unwrap_or(&header.out);
+
+    if out_path == &PathBuf::from("/dev/stdout") {
+        io::stdout().write_all(&out)?;
+    } else {
+        if out_path.exists() {
+            remove_file(&out_path)?;
+        }
+
+        let mut o_file = File::create(&out_path)?;
+        let mut o_file_perm = o_file.metadata()?.permissions();
+        let o_file_perm_mode = o_file_perm.mode();
+        let new_o_file_perm_mode = ((o_file_perm_mode >> 9) << 9) | header.lower_perm_bits;
+        o_file_perm.set_mode(new_o_file_perm_mode);
+
+        o_file.write_all(&out)?;
+        o_file.set_permissions(o_file_perm)?;
     }
+
+    Ok(())
 }
 
 fn pathname_display(path: &Option<PathBuf>) -> String {