mod obj;
use std::env;
use std::fs;
use std::io::Write;
use std::process::{Command, Stdio};
const BORINGSSL_SRC: &str = "boringssl/boringssl";
const BUILD_DIR_1: &str = "boringssl/build_1";
const BUILD_DIR_2: &str = "boringssl/build_2";
const SYMBOL_FILE: &str = "boringssl/symbols.txt";
fn env(name: &str) -> String {
let var =
env::var(name).unwrap_or_else(|_| panic!("missing required environment variable {}", name));
println!("cargo:rerun-if-env-changed={}", var);
var
}
fn main() {
validate_dependencies();
let manifest_dir = env("CARGO_MANIFEST_DIR");
let abs_boringssl_src = format!("{}/{}", manifest_dir, BORINGSSL_SRC);
let out_dir = env("OUT_DIR");
let abs_build_dir_1 = format!("{}/{}", out_dir, BUILD_DIR_1);
let abs_build_dir_2 = format!("{}/{}", out_dir, BUILD_DIR_2);
let abs_symbol_file = format!("{}/{}", out_dir, SYMBOL_FILE);
fs::create_dir_all(&abs_build_dir_1).expect("failed to create first build directory");
fs::create_dir_all(&abs_build_dir_2).expect("failed to create second build directory");
let major = env("CARGO_PKG_VERSION_MAJOR");
let minor = env("CARGO_PKG_VERSION_MINOR");
let patch = env("CARGO_PKG_VERSION_PATCH");
let version_string = format!("{}_{}_{}", major, minor, patch);
let prefix = format!("__RUST_MUNDANE_{}", version_string);
let cmake_version_flag = format!("-DBORINGSSL_PREFIX={}", prefix);
let built_with = built_with(&abs_build_dir_1);
let have_ninja = have_ninja();
let build = |build_dir, flags: &[&str]| {
let mut flags = flags.to_vec();
flags.push("-DCMAKE_POSITION_INDEPENDENT_CODE=1");
fn with_ninja<'a, 'b>(flags: &'a [&'b str]) -> Vec<&'b str> {
let mut flags = flags.to_vec();
flags.push("-GNinja");
flags
}
env::set_current_dir(build_dir).expect("failed to cd to build directory");
match built_with {
Some(BuildSystem::Ninja) => {
run("cmake", &with_ninja(&flags));
run("ninja", &["crypto"]);
}
Some(BuildSystem::Make) => {
run("cmake", &flags);
run("make", &["crypto"]);
}
None => {
if have_ninja {
run("cmake", &with_ninja(&flags));
run("ninja", &["crypto"]);
} else {
run("cmake", &flags);
run("make", &["crypto"]);
}
}
}
};
build(&abs_build_dir_1, &[&abs_boringssl_src]);
let mut symbols = obj::exported_symbols(&format!("{}/crypto/libcrypto.a", &abs_build_dir_1))
.unwrap_or_else(|e| panic!("failed to read list of symbols exported by libcrypto: {}", e));
if symbols.is_empty() {
panic!("no exported symbols found in libcrypto");
}
let symbol_blacklist = [
"__local_stdio_printf_options",
"__local_stdio_scanf_options",
"_vscprintf",
"_vscprintf_l",
"_vsscanf_l",
"_xmm",
"sscanf",
"vsnprintf",
"sdallocx",
];
for blacklisted_symbol in &symbol_blacklist {
symbols.remove(*blacklisted_symbol);
}
let mut symbols_file =
fs::File::create(&abs_symbol_file).expect("could not create symbols file");
for symbol in symbols {
writeln!(symbols_file, "{}", symbol).expect("write to symbols file failed");
}
symbols_file.sync_all().expect("failed to sync the symbols file to filesystem");
build(
&abs_build_dir_2,
&[&abs_boringssl_src, &cmake_version_flag, "-DBORINGSSL_PREFIX_SYMBOLS=../symbols.txt"],
);
#[cfg(unix)]
let res = std::os::unix::fs::symlink(
format!("{}/crypto/libcrypto.a", abs_build_dir_2),
format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string),
);
#[cfg(windows)]
let res = std::os::windows::fs::symlink_file(
format!("{}/crypto/libcrypto.a", abs_build_dir_2),
format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string),
);
#[cfg(not(any(unix, windows)))]
let res = fs::rename(
format!("{}/crypto/libcrypto.a", abs_build_dir_2),
format!("{}/crypto/libcrypto_{}.a", abs_build_dir_2, version_string),
);
if let Err(err) = res {
if err.kind() != std::io::ErrorKind::AlreadyExists {
panic!("could not symlink to libcrypto.a: {}", err)
}
}
println!("cargo:rustc-link-search=native={}/crypto", abs_build_dir_2);
}
fn validate_dependencies() {
let go = have_go();
let cmake = have_cmake();
let ninja = have_ninja();
let make = have_make();
if !go {
panic!(
"
Missing build dependency Go (1.11 or higher).
"
);
}
if !cmake {
panic!(
"
Missing build dependency CMake.
"
);
}
if cfg!(windows) && !ninja {
panic!(
"
Building on Windows requires the Ninja tool. See https://ninja-build.org/.
"
);
}
if !make && !ninja {
panic!(
"
Building requires either Make or Ninja (https://ninja-build.org/).
"
);
}
}
fn run(cmd: &str, args: &[&str]) {
let output = Command::new(cmd)
.args(args)
.stdout(Stdio::inherit())
.stderr(Stdio::inherit())
.output()
.unwrap_or_else(|_| panic!("failed to invoke {}", cmd));
if !output.status.success() {
panic!("{} failed with status {}", cmd, output.status);
}
}
fn have_go() -> bool {
have("go", &["version"])
}
fn have_cmake() -> bool {
have("cmake", &["--version"])
}
fn have_ninja() -> bool {
have("ninja", &["--version"])
}
fn have_make() -> bool {
have("make", &["--version"])
}
fn have(name: &str, args: &[&str]) -> bool {
Command::new(name).args(args).output().map(|output| output.status.success()).unwrap_or(false)
}
enum BuildSystem {
Ninja,
Make,
}
fn built_with(abs_dir: &str) -> Option<BuildSystem> {
let is_file = |file| {
fs::metadata(format!("{}/{}", abs_dir, file)).map(|meta| meta.is_file()).unwrap_or(false)
};
if is_file("build.ninja") {
Some(BuildSystem::Ninja)
} else if is_file("Makefile") {
Some(BuildSystem::Make)
} else {
None
}
}