coreutils/base64/base64.rs

182 lines
4.9 KiB
Rust
Raw Normal View History

2013-12-27 22:01:55 +00:00
#[crate_id(name="base64", vers="1.0.0", author="Jordy Dickinson")];
2013-12-20 19:34:45 +00:00
/*
* This file is part of the uutils coreutils package.
*
* (c) Jordy Dickinson <jordy.dickinson@gmail.com>
*
* For the full copyright and license information, please view the LICENSE file
* that was distributed with this source code.
*/
#[feature(macro_rules)];
extern crate serialize;
extern crate getopts;
2013-12-20 19:34:45 +00:00
use std::char;
use std::io::{println, File, stdin, stdout};
2013-12-20 19:34:45 +00:00
use std::os;
use std::str;
use getopts::{
getopts,
optflag,
optopt,
usage
};
2014-02-15 04:50:03 +00:00
use serialize::base64;
use serialize::base64::{FromBase64, ToBase64};
2013-12-20 19:34:45 +00:00
#[path = "../util.rs"]
mod util;
static NAME: &'static str = "base64";
2013-12-20 19:34:45 +00:00
fn main() {
let args = ~os::args();
let opts = ~[
optflag("d", "decode", "decode data"),
optflag("i", "ignore-garbage", "when decoding, ignore non-alphabetic characters"),
optopt("w", "wrap",
"wrap encoded lines after COLS character (default 76, 0 to disable wrapping)", "COLS"
),
optflag("h", "help", "display this help text and exit"),
optflag("V", "version", "output version information and exit")
];
let matches = match getopts(args.tail(), opts) {
Ok(m) => m,
Err(e) => {
error!("error: {:s}", e.to_err_msg());
fail!()
}
};
let progname = args[0].clone();
let usage = usage("Base64 encode or decode FILE, or standard input, to standard output.", opts);
let mode = if matches.opt_present("help") {
Help
} else if matches.opt_present("version") {
Version
} else if matches.opt_present("decode") {
Decode
} else {
Encode
};
let ignore_garbage = matches.opt_present("ignore-garbage");
let line_wrap = match matches.opt_str("wrap") {
Some(s) => match from_str(s) {
Some(s) => s,
None => {
error!("error: {:s}", "Argument to option 'wrap' improperly formatted.");
fail!()
}
},
None => 76
};
let mut input = if matches.free.is_empty() || matches.free[0] == ~"-" {
~stdin() as ~Reader
} else {
let path = Path::new(matches.free[0]);
~File::open(&path) as ~Reader
};
2013-12-20 19:34:45 +00:00
match mode {
Decode => decode(input, ignore_garbage),
Encode => encode(input, line_wrap),
Help => help(progname, usage),
2013-12-20 19:34:45 +00:00
Version => version()
}
}
fn decode(input: &mut Reader, ignore_garbage: bool) {
2014-02-05 03:39:17 +00:00
let mut to_decode = str::from_utf8_owned(match input.read_to_end() {
Ok(m) => m,
Err(f) => fail!(f.to_str())
}).unwrap();
2013-12-20 19:34:45 +00:00
to_decode = str::replace(to_decode, "\n", "");
2013-12-20 19:34:45 +00:00
if ignore_garbage {
2013-12-20 19:34:45 +00:00
let standard_chars =
bytes!("ABCDEFGHIJKLMNOPQRSTUVWXYZ",
"abcdefghijklmnopqrstuvwxyz",
"0123456789+/").map(|b| char::from_u32(*b as u32).unwrap());
2013-12-20 19:34:45 +00:00
to_decode = to_decode
.trim_chars(&|c| !standard_chars.contains(&c))
.to_owned();
}
match to_decode.from_base64() {
Ok(bytes) => {
let mut out = stdout();
match out.write(bytes) {
Ok(_) => {}
Err(f) => { crash!(1, "{}", f.to_str()); }
}
match out.flush() {
Ok(_) => {}
Err(f) => { crash!(1, "{}", f.to_str()); }
}
2013-12-20 19:34:45 +00:00
}
2013-12-20 21:15:27 +00:00
Err(s) => {
error!("error: {}", s.to_str());
2013-12-20 21:15:27 +00:00
fail!()
}
2013-12-20 19:34:45 +00:00
}
}
fn encode(input: &mut Reader, line_wrap: uint) {
2013-12-20 19:34:45 +00:00
let b64_conf = base64::Config {
char_set: base64::Standard,
pad: true,
line_length: match line_wrap {
2013-12-20 19:34:45 +00:00
0 => None,
_ => Some(line_wrap)
2013-12-20 19:34:45 +00:00
}
};
2014-02-05 03:39:17 +00:00
let to_encode = match input.read_to_end() {
Ok(m) => m,
Err(f) => fail!(f.to_str())
};
2013-12-20 19:34:45 +00:00
let mut encoded = to_encode.to_base64(b64_conf);
// To my knowledge, RFC 3548 does not specify which line endings to use. It
// seems that rust's base64 algorithm uses CRLF as prescribed by RFC 2045.
// However, since GNU base64 outputs only LF (presumably because that is
// the standard UNIX line ending), we strip CRs from the output to maintain
// compatibility.
encoded = encoded.replace("\r", "");
println(encoded);
}
fn help(progname: &str, usage: &str) {
println!("Usage: {:s} [OPTION]... [FILE]", progname);
println!("");
println(usage);
2013-12-20 19:34:45 +00:00
let msg = ~"With no FILE, or when FILE is -, read standard input.\n\n\
The data are encoded as described for the base64 alphabet in RFC \
3548. When\ndecoding, the input may contain newlines in addition \
to the bytes of the formal\nbase64 alphabet. Use --ignore-garbage \
to attempt to recover from any other\nnon-alphabet bytes in the \
encoded stream.";
2013-12-20 19:34:45 +00:00
println(msg);
}
fn version() {
println!("base64 1.0.0");
2013-12-20 19:34:45 +00:00
}
enum Mode {
Decode,
Encode,
Help,
Version
}