2014-07-06 08:13:36 +00:00
|
|
|
#![crate_name = "base64"]
|
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.
|
|
|
|
*/
|
|
|
|
|
2014-03-31 16:40:21 +00:00
|
|
|
#![feature(phase)]
|
|
|
|
#![feature(macro_rules)]
|
2014-02-07 06:39:07 +00:00
|
|
|
|
2014-02-16 21:29:31 +00:00
|
|
|
extern crate serialize;
|
|
|
|
extern crate getopts;
|
2014-04-07 22:43:34 +00:00
|
|
|
extern crate libc;
|
2014-06-12 04:43:47 +00:00
|
|
|
#[phase(plugin, link)] extern crate log;
|
2013-12-20 19:34:45 +00:00
|
|
|
|
2014-01-13 09:55:04 +00:00
|
|
|
use std::io::{println, File, stdin, stdout};
|
2013-12-20 19:34:45 +00:00
|
|
|
use std::str;
|
|
|
|
|
2014-02-07 06:39:07 +00:00
|
|
|
use getopts::{
|
2013-12-27 16:27:41 +00:00
|
|
|
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
|
|
|
|
2014-02-23 22:17:48 +00:00
|
|
|
#[path = "../common/util.rs"]
|
2014-02-07 06:39:07 +00:00
|
|
|
mod util;
|
|
|
|
|
|
|
|
static NAME: &'static str = "base64";
|
|
|
|
|
2014-06-08 07:56:37 +00:00
|
|
|
pub fn uumain(args: Vec<String>) -> int {
|
2014-05-30 08:35:54 +00:00
|
|
|
let opts = [
|
2013-12-27 16:27:41 +00:00
|
|
|
optflag("d", "decode", "decode data"),
|
2014-01-07 00:35:24 +00:00
|
|
|
optflag("i", "ignore-garbage", "when decoding, ignore non-alphabetic characters"),
|
2013-12-27 16:27:41 +00:00
|
|
|
optopt("w", "wrap",
|
2014-01-07 00:35:24 +00:00
|
|
|
"wrap encoded lines after COLS character (default 76, 0 to disable wrapping)", "COLS"
|
|
|
|
),
|
2013-12-27 16:27:41 +00:00
|
|
|
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) => {
|
2014-06-15 10:50:40 +00:00
|
|
|
error!("error: {}", e);
|
2013-12-27 16:27:41 +00:00
|
|
|
fail!()
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2014-05-16 08:32:58 +00:00
|
|
|
let progname = args.get(0).clone();
|
2014-01-07 00:35:24 +00:00
|
|
|
let usage = usage("Base64 encode or decode FILE, or standard input, to standard output.", opts);
|
2013-12-27 16:27:41 +00:00
|
|
|
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") {
|
2014-05-17 10:32:14 +00:00
|
|
|
Some(s) => match from_str(s.as_slice()) {
|
2013-12-27 16:27:41 +00:00
|
|
|
Some(s) => s,
|
|
|
|
None => {
|
2014-01-07 00:35:24 +00:00
|
|
|
error!("error: {:s}", "Argument to option 'wrap' improperly formatted.");
|
2013-12-27 16:27:41 +00:00
|
|
|
fail!()
|
|
|
|
}
|
|
|
|
},
|
|
|
|
None => 76
|
|
|
|
};
|
2014-03-22 08:18:52 +00:00
|
|
|
let mut input = if matches.free.is_empty() || matches.free.get(0).as_slice() == "-" {
|
2014-05-09 00:12:57 +00:00
|
|
|
box stdin() as Box<Reader>
|
2013-12-27 16:27:41 +00:00
|
|
|
} else {
|
2014-03-22 08:18:52 +00:00
|
|
|
let path = Path::new(matches.free.get(0).clone());
|
2014-05-09 00:12:57 +00:00
|
|
|
box File::open(&path) as Box<Reader>
|
2013-12-27 16:27:41 +00:00
|
|
|
};
|
2013-12-20 19:34:45 +00:00
|
|
|
|
2013-12-27 16:27:41 +00:00
|
|
|
match mode {
|
|
|
|
Decode => decode(input, ignore_garbage),
|
|
|
|
Encode => encode(input, line_wrap),
|
2014-05-17 10:32:14 +00:00
|
|
|
Help => help(progname.as_slice(), usage.as_slice()),
|
2013-12-20 19:34:45 +00:00
|
|
|
Version => version()
|
|
|
|
}
|
2014-06-08 07:56:37 +00:00
|
|
|
|
2014-06-12 04:41:53 +00:00
|
|
|
0
|
2013-12-20 19:34:45 +00:00
|
|
|
}
|
|
|
|
|
2013-12-27 16:27:41 +00:00
|
|
|
fn decode(input: &mut Reader, ignore_garbage: bool) {
|
2014-07-09 08:29:50 +00:00
|
|
|
let mut to_decode = match input.read_to_string() {
|
2014-02-05 03:39:17 +00:00
|
|
|
Ok(m) => m,
|
2014-07-09 08:29:50 +00:00
|
|
|
Err(f) => fail!(f.to_string())
|
2014-04-25 17:38:09 +00:00
|
|
|
};
|
2013-12-20 19:34:45 +00:00
|
|
|
|
2014-05-23 12:28:40 +00:00
|
|
|
to_decode = str::replace(to_decode.as_slice(), "\n", "");
|
2013-12-20 19:34:45 +00:00
|
|
|
|
2013-12-27 16:27:41 +00:00
|
|
|
if ignore_garbage {
|
2014-05-16 08:34:32 +00:00
|
|
|
let standard_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
|
2014-05-23 12:28:40 +00:00
|
|
|
to_decode = to_decode.as_slice()
|
2014-05-16 08:34:32 +00:00
|
|
|
.trim_chars(|c| !standard_chars.contains_char(c))
|
2014-06-01 00:41:32 +00:00
|
|
|
.into_string()
|
2013-12-20 19:34:45 +00:00
|
|
|
}
|
|
|
|
|
2014-05-23 12:28:40 +00:00
|
|
|
match to_decode.as_slice().from_base64() {
|
2013-12-20 19:34:45 +00:00
|
|
|
Ok(bytes) => {
|
|
|
|
let mut out = stdout();
|
|
|
|
|
2014-05-16 08:34:02 +00:00
|
|
|
match out.write(bytes.as_slice()) {
|
2014-02-07 06:39:07 +00:00
|
|
|
Ok(_) => {}
|
2014-07-09 08:29:50 +00:00
|
|
|
Err(f) => { crash!(1, "{}", f.to_string()); }
|
2014-02-07 06:39:07 +00:00
|
|
|
}
|
|
|
|
match out.flush() {
|
|
|
|
Ok(_) => {}
|
2014-07-09 08:29:50 +00:00
|
|
|
Err(f) => { crash!(1, "{}", f.to_string()); }
|
2014-02-07 06:39:07 +00:00
|
|
|
}
|
2013-12-20 19:34:45 +00:00
|
|
|
}
|
2013-12-20 21:15:27 +00:00
|
|
|
Err(s) => {
|
2014-07-09 08:29:50 +00:00
|
|
|
error!("error: {}", s.to_string());
|
2013-12-20 21:15:27 +00:00
|
|
|
fail!()
|
|
|
|
}
|
2013-12-20 19:34:45 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2013-12-27 16:27:41 +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,
|
2013-12-27 16:27:41 +00:00
|
|
|
line_length: match line_wrap {
|
2013-12-20 19:34:45 +00:00
|
|
|
0 => None,
|
2013-12-27 16:27:41 +00:00
|
|
|
_ => 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,
|
2014-07-09 08:29:50 +00:00
|
|
|
Err(f) => fail!(f.to_string())
|
2014-02-05 03:39:17 +00:00
|
|
|
};
|
2014-05-17 10:32:14 +00:00
|
|
|
let encoded = to_encode.as_slice().to_base64(b64_conf);
|
2013-12-20 19:34:45 +00:00
|
|
|
|
|
|
|
// 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.
|
2014-05-17 10:32:14 +00:00
|
|
|
let final = encoded.replace("\r", "");
|
2013-12-20 19:34:45 +00:00
|
|
|
|
2014-05-23 12:28:40 +00:00
|
|
|
println(final.as_slice());
|
2013-12-20 19:34:45 +00:00
|
|
|
}
|
|
|
|
|
2013-12-27 16:27:41 +00:00
|
|
|
fn help(progname: &str, usage: &str) {
|
|
|
|
println!("Usage: {:s} [OPTION]... [FILE]", progname);
|
2014-01-13 09:55:04 +00:00
|
|
|
println!("");
|
2013-12-27 16:27:41 +00:00
|
|
|
println(usage);
|
2013-12-20 19:34:45 +00:00
|
|
|
|
2014-05-07 06:25:49 +00:00
|
|
|
let msg = "With no FILE, or when FILE is -, read standard input.\n\n\
|
2013-12-21 03:27:49 +00:00
|
|
|
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() {
|
2014-01-13 09:55:04 +00:00
|
|
|
println!("base64 1.0.0");
|
2013-12-20 19:34:45 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
enum Mode {
|
|
|
|
Decode,
|
|
|
|
Encode,
|
|
|
|
Help,
|
|
|
|
Version
|
|
|
|
}
|
|
|
|
|