102 lines
2.7 KiB
Rust
102 lines
2.7 KiB
Rust
// Copyright (c) 2022 YAC
|
|
// SPDX-License-Identifier: AGPL-3.0-or-later
|
|
|
|
/* This file is part of YAC coreutils.
|
|
*
|
|
* YAC coreutils 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.
|
|
*
|
|
* YAC coreutils 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;
|
|
use std::fs::{ File, read_to_string };
|
|
use std::os::fd::{ AsRawFd, FromRawFd };
|
|
use std::io::{ self, Read, Write };
|
|
use std::str;
|
|
|
|
use arg::Args;
|
|
|
|
use sysexits::ExitCode;
|
|
|
|
#[derive(Args, Debug)]
|
|
struct Arguments {
|
|
argv0: String,
|
|
|
|
#[arg(short = "u")]
|
|
u: bool,
|
|
|
|
paths: Vec<String>,
|
|
}
|
|
|
|
fn main() -> ExitCode {
|
|
let mut args = Arguments::from_args(env::args()
|
|
.collect::<Vec<String>>()
|
|
.iter()
|
|
.map(String::as_str)
|
|
.collect::<Vec<&str>>()
|
|
).unwrap();
|
|
|
|
let argv0 = args.argv0;
|
|
let mut output: Vec<u8> = vec![];
|
|
let stdin = io::stdin();
|
|
|
|
if args.paths.is_empty() { args.paths.push("-".to_string()); }
|
|
|
|
if args.u {
|
|
for path in args.paths {
|
|
let handle: File;
|
|
if path == "-" {
|
|
handle = unsafe {
|
|
File::from_raw_fd(stdin.as_raw_fd())
|
|
}
|
|
} else {
|
|
handle = match File::open(&path) {
|
|
Ok(file) => file,
|
|
Err(_) => {
|
|
eprintln!("{}: {}: No such file or directory.", &argv0, &path);
|
|
return ExitCode::NoInput;
|
|
},
|
|
};
|
|
}
|
|
let mut stdout = io::BufWriter::with_capacity(0, io::stdout());
|
|
|
|
for byte in handle.bytes() {
|
|
stdout.write(&[byte.unwrap()]).unwrap();
|
|
stdout.flush().unwrap();
|
|
}
|
|
} return ExitCode::Ok;
|
|
} else {
|
|
let mut stdout = io::stdout();
|
|
for path in args.paths {
|
|
if path == "-" {
|
|
let mut bytes: Vec<u8> = Vec::new();
|
|
stdin.lock().read_to_end(&mut bytes).unwrap();
|
|
|
|
for byte in &bytes {
|
|
output.push(byte.to_owned());
|
|
}
|
|
} else {
|
|
match read_to_string(&path) {
|
|
Ok(contents) => output.append(&mut contents.as_bytes().to_owned()),
|
|
Err(_) => {
|
|
eprintln!("{}: {}: No such file or directory.", &argv0, &path);
|
|
return ExitCode::NoInput;
|
|
},
|
|
};
|
|
}
|
|
stdout.write(&output[..]);
|
|
output.clear();
|
|
}
|
|
}
|
|
ExitCode::Ok
|
|
}
|