overgrown/src/mm.rs

/*
 * Copyright (c) 2024 Emma Tebibyte <emma@tebibyte.media>
 * SPDX-License-Identifier: AGPL-3.0-or-later
 *
 * This program is free software: you can redistribute it and/or modify it under
 * the terms of the GNU Affero General Public License as published by the Free
 * Software Foundation, either version 3 of the License, or (at your option) any
 * later version.
 * 
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see https://www.gnu.org/licenses/.
 */

use std::{
	env::args,
	fs::File,
	io::{ stdin, stdout, stderr, BufWriter, Read, Write },
	os::fd::{ AsRawFd, FromRawFd },
	process::{ exit, ExitCode },
};

extern crate getopt;
extern crate strerror;
extern crate sysexits;

use getopt::GetOpt;
use strerror::StrError;
use sysexits::{ EX_IOERR, EX_USAGE };

fn main() -> ExitCode {
	let argv = args().collect::<Vec<_>>();
	let usage = format!("Usage: {} [-aetu] [-i input] [-o output]", argv[0]);

	let mut a = false; /* append rather than update */
	let mut e = false; /* use stderr as an output */
	let mut t = true;
	let mut u = false; /* unbuffer i/o */
	let mut ins = Vec::new(); /* initial inputs vector */
	let mut outs = Vec::new(); /* initial outputs vector */

	while let Some(opt) = argv.getopt("aei:o:tu") {
		match opt.opt() {
			Ok("a") => a = true,
			Ok("e") => e = true, 
			Ok("u") => u = true,
			Ok("t") => t = false,
			Ok("i") => { /* add input */
				let input = opt.arg().unwrap();
				ins.push(input);
			},
			Ok("o") => { /* add output */
				let output = opt.arg().unwrap(); 
				outs.push(output);
			},
			Err(_) | Ok(_) => {
				eprintln!("{}", usage);
				return ExitCode::from(EX_USAGE as u8);
			},
		};
	}

	/* use stdin if no inputs are specified */
	if ins.is_empty() { ins.push("-".to_string()); }

	/* use stdout if no outputs are specified */
	if outs.is_empty() { outs.push("-".to_string()); }
	
	/* map all path strings to files */
	let inputs = ins.iter().map(|file| {
		/* if a file is “-”, it is stdin */
		if *file == "-" {
			return unsafe { File::from_raw_fd(stdin().as_raw_fd()) }; /* fd0 = stdin */
		}

		match File::options().open(file) {
			Ok(f) => f,
			Err(e) => {
				eprintln!("{}: {}", argv[0], e.strerror());
				exit(EX_IOERR);
			},
		}
	}).collect::<Vec<_>>();

	/* map all path strings to files */
	let mut outputs = outs.iter().map(|file| {
		/* of a file is “-”, it is stdout */
		if *file == "-" {
			return unsafe { File::from_raw_fd(stdout().as_raw_fd()) }; /* fd1 = stdout */
		}

		match File::options().truncate(t).append(a).open(file) {
			Ok(f) => return f,
			Err(e) => {
				eprintln!("{}: {}", argv[0], e.strerror());
				exit(EX_IOERR);
			},
		};
	}).collect::<Vec<_>>();

	/* if -e is specified, use stderr */
	if e {
		outputs.push(unsafe { File::from_raw_fd(stderr().as_raw_fd()) }); /* fd2 = stderr */
	}

	let mut outputs = outputs.iter().map(|o| {
		if u {
			BufWriter::with_capacity(0, o)
		} else {
			BufWriter::new(o)
		}
	}).collect::<Vec<_>>();

	for file in inputs {
		for byte in file.bytes().map(|b| {
			b.unwrap_or_else(|e| {
				eprintln!("{}: {}", argv[0], e.strerror());
				exit(EX_IOERR);
			})
		}) {
			for out in &mut outputs {
				if let Err(e) = out.write(&[byte]) {
					eprintln!("{}: {}", argv[0], e.strerror());
					return ExitCode::from(EX_IOERR as u8);
				}
				if let Err(e) = out.flush() {
					eprintln!("{}: {}", argv[0], e.strerror());
					return ExitCode::from(EX_IOERR as u8);
				}
			}
		}
	}

	ExitCode::SUCCESS
}