Merge pull request #1070 from sfackler/build-script-cleanup (5faeeb5c) · Commits · Public Repositories / Rust Openssl

openssl-sys/build/expando.c

0 → 100644

+67 −0

Original line number	Diff line number	Diff line
		#include <openssl/opensslv.h>
		#include <openssl/opensslconf.h>

		#define VERSION2(n, v) RUST_VERSION_##n##_##v
		#define VERSION(n, v) VERSION2(n, v)

		#ifdef LIBRESSL_VERSION_NUMBER
		VERSION(LIBRESSL, LIBRESSL_VERSION_NUMBER)
		#else
		VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)
		#endif

		#ifdef OPENSSL_NO_BUF_FREELISTS
		RUST_CONF_OPENSSL_NO_BUF_FREELISTS
		#endif

		#ifdef OPENSSL_NO_COMP
		RUST_CONF_OPENSSL_NO_COMP
		#endif

		#ifdef OPENSSL_NO_EC
		RUST_CONF_OPENSSL_NO_EC
		#endif

		#ifdef OPENSSL_NO_EC2M
		RUST_CONF_OPENSSL_NO_EC2M
		#endif

		#ifdef OPENSSL_NO_ENGINE
		RUST_CONF_OPENSSL_NO_ENGINE
		#endif

		#ifdef OPENSSL_NO_KRB5
		RUST_CONF_OPENSSL_NO_KRB5
		#endif

		#ifdef OPENSSL_NO_NEXTPROTONEG
		RUST_CONF_OPENSSL_NO_NEXTPROTONEG
		#endif

		#ifdef OPENSSL_NO_PSK
		RUST_CONF_OPENSSL_NO_PSK
		#endif

		#ifdef OPENSSL_NO_RFC3779
		RUST_CONF_OPENSSL_NO_RFC3779
		#endif

		#ifdef OPENSSL_NO_SHA
		RUST_CONF_OPENSSL_NO_SHA
		#endif

		#ifdef OPENSSL_NO_SRP
		RUST_CONF_OPENSSL_NO_SRP
		#endif

		#ifdef OPENSSL_NO_SSL3_METHOD
		RUST_CONF_OPENSSL_NO_SSL3_METHOD
		#endif

		#ifdef OPENSSL_NO_TLSEXT
		RUST_CONF_OPENSSL_NO_TLSEXT
		#endif

		#ifdef OPENSSL_NO_STDIO
		RUST_CONF_OPENSSL_NO_STDIO
		#endif

openssl-sys/build/find_normal.rs

0 → 100644

+251 −0

Original line number	Diff line number	Diff line
		use pkg_config;
		use std::ffi::OsString;
		use std::path::{Path, PathBuf};
		use std::process::{self, Command};

		use super::env;

		pub fn get_openssl(target: &str) -> (PathBuf, PathBuf) {
		let lib_dir = env("OPENSSL_LIB_DIR").map(PathBuf::from);
		let include_dir = env("OPENSSL_INCLUDE_DIR").map(PathBuf::from);

		if lib_dir.is_none() \|\| include_dir.is_none() {
		let openssl_dir = env("OPENSSL_DIR").unwrap_or_else(\|\| find_openssl_dir(&target));
		let openssl_dir = Path::new(&openssl_dir);
		let lib_dir = lib_dir.unwrap_or_else(\|\| openssl_dir.join("lib"));
		let include_dir = include_dir.unwrap_or_else(\|\| openssl_dir.join("include"));
		(lib_dir, include_dir)
		} else {
		(lib_dir.unwrap(), include_dir.unwrap())
		}
		}

		fn find_openssl_dir(target: &str) -> OsString {
		let host = env::var("HOST").unwrap();

		if host == target && target.contains("apple-darwin") {
		// Check up default Homebrew installation location first
		// for quick resolution if possible.
		let homebrew = Path::new("/usr/local/opt/openssl@1.1");
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		let homebrew = Path::new("/usr/local/opt/openssl");
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		// Calling `brew --prefix <package>` command usually slow and
		// takes seconds, and will be used only as a last resort.
		let output = execute_command_and_get_output("brew", &["--prefix", "openssl@1.1"]);
		if let Some(ref output) = output {
		let homebrew = Path::new(&output);
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		}
		let output = execute_command_and_get_output("brew", &["--prefix", "openssl"]);
		if let Some(ref output) = output {
		let homebrew = Path::new(&output);
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		}
		}

		try_pkg_config();
		try_vcpkg();

		// FreeBSD ships with OpenSSL but doesn't include a pkg-config file :(
		if host == target && target.contains("freebsd") {
		return OsString::from("/usr");
		}

		let mut msg = format!(
		"

		Could not find directory of OpenSSL installation, and this `-sys` crate cannot
		proceed without this knowledge. If OpenSSL is installed and this crate had
		trouble finding it, you can set the `OPENSSL_DIR` environment variable for the
		compilation process.

		Make sure you also have the development packages of openssl installed.
		For example, `libssl-dev` on Ubuntu or `openssl-devel` on Fedora.

		If you're in a situation where you think the directory should be found
		automatically, please open a bug at https://github.com/sfackler/rust-openssl
		and include information about your system as well as this message.

		$HOST = {}
		$TARGET = {}
		openssl-sys = {}

		",
		host,
		target,
		env!("CARGO_PKG_VERSION")
		);

		if host.contains("apple-darwin") && target.contains("apple-darwin") {
		let system = Path::new("/usr/lib/libssl.0.9.8.dylib");
		if system.exists() {
		msg.push_str(&format!(
		"

		It looks like you're compiling on macOS, where the system contains a version of
		OpenSSL 0.9.8. This crate no longer supports OpenSSL 0.9.8.

		As a consumer of this crate, you can fix this error by using Homebrew to
		install the `openssl` package, or as a maintainer you can use the openssl-sys
		0.7 crate for support with OpenSSL 0.9.8.

		Unfortunately though the compile cannot continue, so aborting.

		"
		));
		}
		}

		if host.contains("unknown-linux") && target.contains("unknown-linux-gnu") {
		if Command::new("pkg-config").output().is_err() {
		msg.push_str(&format!(
		"
		It looks like you're compiling on Linux and also targeting Linux. Currently this
		requires the `pkg-config` utility to find OpenSSL but unfortunately `pkg-config`
		could not be found. If you have OpenSSL installed you can likely fix this by
		installing `pkg-config`.

		"
		));
		}
		}

		if host.contains("windows") && target.contains("windows-gnu") {
		msg.push_str(&format!(
		"
		It looks like you're compiling for MinGW but you may not have either OpenSSL or
		pkg-config installed. You can install these two dependencies with:

		pacman -S openssl-devel pkg-config

		and try building this crate again.

		"
		));
		}

		if host.contains("windows") && target.contains("windows-msvc") {
		msg.push_str(&format!(
		"
		It looks like you're compiling for MSVC but we couldn't detect an OpenSSL
		installation. If there isn't one installed then you can try the rust-openssl
		README for more information about how to download precompiled binaries of
		OpenSSL:

		https://github.com/sfackler/rust-openssl#windows

		"
		));
		}

		panic!(msg);
		}

		/// Attempt to find OpenSSL through pkg-config.
		///
		/// Note that if this succeeds then the function does not return as pkg-config
		/// typically tells us all the information that we need.
		fn try_pkg_config() {
		let target = env::var("TARGET").unwrap();
		let host = env::var("HOST").unwrap();

		// If we're going to windows-gnu we can use pkg-config, but only so long as
		// we're coming from a windows host.
		//
		// Otherwise if we're going to windows we probably can't use pkg-config.
		if target.contains("windows-gnu") && host.contains("windows") {
		env::set_var("PKG_CONFIG_ALLOW_CROSS", "1");
		} else if target.contains("windows") {
		return;
		}

		let lib = match pkg_config::Config::new()
		.print_system_libs(false)
		.find("openssl")
		{
		Ok(lib) => lib,
		Err(e) => {
		println!("run pkg_config fail: {:?}", e);
		return;
		}
		};

		super::validate_headers(&lib.include_paths);

		for include in lib.include_paths.iter() {
		println!("cargo:include={}", include.display());
		}

		process::exit(0);
		}

		/// Attempt to find OpenSSL through vcpkg.
		///
		/// Note that if this succeeds then the function does not return as vcpkg
		/// should emit all of the cargo metadata that we need.
		#[cfg(target_env = "msvc")]
		fn try_vcpkg() {
		use vcpkg;

		// vcpkg will not emit any metadata if it can not find libraries
		// appropriate for the target triple with the desired linkage.

		let mut lib = vcpkg::Config::new()
		.emit_includes(true)
		.lib_name("libcrypto")
		.lib_name("libssl")
		.probe("openssl");

		if let Err(e) = lib {
		println!(
		"note: vcpkg did not find openssl as libcrypto and libssl: {}",
		e
		);
		lib = vcpkg::Config::new()
		.emit_includes(true)
		.lib_name("libeay32")
		.lib_name("ssleay32")
		.probe("openssl");
		}
		if let Err(e) = lib {
		println!(
		"note: vcpkg did not find openssl as ssleay32 and libeay32: {}",
		e
		);
		return;
		}

		let lib = lib.unwrap();
		super::validate_headers(&lib.include_paths);

		println!("cargo:rustc-link-lib=user32");
		println!("cargo:rustc-link-lib=gdi32");
		println!("cargo:rustc-link-lib=crypt32");

		process::exit(0);
		}

		#[cfg(not(target_env = "msvc"))]
		fn try_vcpkg() {}

		fn execute_command_and_get_output(cmd: &str, args: &[&str]) -> Option<String> {
		let out = Command::new(cmd).args(args).output();
		if let Ok(ref r1) = out {
		if r1.status.success() {
		let r2 = String::from_utf8(r1.stdout.clone());
		if let Ok(r3) = r2 {
		return Some(r3.trim().to_string());
		}
		}
		}
		return None;
		}

openssl-sys/build/find_vendored.rs

0 → 100644

+10 −0

Original line number	Diff line number	Diff line
		use openssl_src;
		use std::path::PathBuf;

		pub fn get_openssl(_target: &str) -> (PathBuf, PathBuf) {
		let artifacts = openssl_src::Build::new().build();
		(
		artifacts.lib_dir().to_path_buf(),
		artifacts.include_dir().to_path_buf(),
		)
		}

openssl-sys/build/main.rs

+18 −337

Original line number	Diff line number	Diff line
		@@ -8,29 +8,13 @@ extern crate vcpkg;
		use std::collections::HashSet;
		use std::env;
		use std::ffi::OsString;
		use std::fs::File;
		use std::io::{BufWriter, Write};
		use std::path::{Path, PathBuf};

		mod cfgs;

		// The set of `OPENSSL_NO_<FOO>`s that we care about.
		const DEFINES: &'static [&'static str] = &[
		"OPENSSL_NO_BUF_FREELISTS",
		"OPENSSL_NO_COMP",
		"OPENSSL_NO_EC",
		"OPENSSL_NO_EC2M",
		"OPENSSL_NO_ENGINE",
		"OPENSSL_NO_KRB5",
		"OPENSSL_NO_NEXTPROTONEG",
		"OPENSSL_NO_PSK",
		"OPENSSL_NO_RFC3779",
		"OPENSSL_NO_SHA",
		"OPENSSL_NO_SRP",
		"OPENSSL_NO_SSL3_METHOD",
		"OPENSSL_NO_TLSEXT",
		"OPENSSL_NO_STDIO",
		];
		#[cfg_attr(feature = "vendored", path = "find_vendored.rs")]
		#[cfg_attr(not(feature = "vendored"), path = "find_normal.rs")]
		mod find;

		enum Version {
		Openssl11x,
		@@ -38,23 +22,28 @@ enum Version {
		Libressl,
		}

		fn env(name: &str) -> Option<OsString> {
		let prefix = env::var("TARGET").unwrap().to_uppercase().replace("-", "_");
		let prefixed = format!("{}_{}", prefix, name);
		println!("cargo:rerun-if-env-changed={}", prefixed);
		fn env_inner(name: &str) -> Option<OsString> {
		let var = env::var_os(name);
		println!("cargo:rerun-if-env-changed={}", name);

		if let Some(var) = env::var_os(&prefixed) {
		return Some(var);
		match var {
		Some(ref v) => println!("{} = {}", name, v.to_string_lossy()),
		None => println!("{} unset", name),
		}

		println!("cargo:rerun-if-env-changed={}", name);
		env::var_os(name)
		var
		}

		fn env(name: &str) -> Option<OsString> {
		let prefix = env::var("TARGET").unwrap().to_uppercase().replace("-", "_");
		let prefixed = format!("{}_{}", prefix, name);
		env_inner(&prefixed).or_else(\|\| env_inner(name))
		}

		fn main() {
		let target = env::var("TARGET").unwrap();

		let (lib_dir, include_dir) = imp::get_openssl(&target);
		let (lib_dir, include_dir) = find::get_openssl(&target);

		if !Path::new(&lib_dir).exists() {
		panic!(
		@@ -101,275 +90,6 @@ fn main() {
		}
		}

		#[cfg(feature = "vendored")]
		mod imp {
		use openssl_src;
		use std::path::PathBuf;

		pub fn get_openssl(_target: &str) -> (PathBuf, PathBuf) {
		let artifacts = openssl_src::Build::new().build();
		(
		artifacts.lib_dir().to_path_buf(),
		artifacts.include_dir().to_path_buf(),
		)
		}
		}

		#[cfg(not(feature = "vendored"))]
		mod imp {
		use pkg_config;
		use std::ffi::OsString;
		use std::path::{Path, PathBuf};
		use std::process::{self, Command};

		use super::env;

		pub fn get_openssl(target: &str) -> (PathBuf, PathBuf) {
		let lib_dir = env("OPENSSL_LIB_DIR").map(PathBuf::from);
		let include_dir = env("OPENSSL_INCLUDE_DIR").map(PathBuf::from);

		if lib_dir.is_none() \|\| include_dir.is_none() {
		let openssl_dir = env("OPENSSL_DIR").unwrap_or_else(\|\| find_openssl_dir(&target));
		let openssl_dir = Path::new(&openssl_dir);
		let lib_dir = lib_dir.unwrap_or_else(\|\| openssl_dir.join("lib"));
		let include_dir = include_dir.unwrap_or_else(\|\| openssl_dir.join("include"));
		(lib_dir, include_dir)
		} else {
		(lib_dir.unwrap(), include_dir.unwrap())
		}
		}

		fn find_openssl_dir(target: &str) -> OsString {
		let host = env::var("HOST").unwrap();

		if host == target && target.contains("apple-darwin") {
		// Check up default Homebrew installation location first
		// for quick resolution if possible.
		let homebrew = Path::new("/usr/local/opt/openssl@1.1");
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		let homebrew = Path::new("/usr/local/opt/openssl");
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		// Calling `brew --prefix <package>` command usually slow and
		// takes seconds, and will be used only as a last resort.
		let output = execute_command_and_get_output("brew", &["--prefix", "openssl@1.1"]);
		if let Some(ref output) = output {
		let homebrew = Path::new(&output);
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		}
		let output = execute_command_and_get_output("brew", &["--prefix", "openssl"]);
		if let Some(ref output) = output {
		let homebrew = Path::new(&output);
		if homebrew.exists() {
		return homebrew.to_path_buf().into();
		}
		}
		}

		try_pkg_config();
		try_vcpkg();

		// FreeBSD ships with OpenSSL but doesn't include a pkg-config file :(
		if host == target && target.contains("freebsd") {
		return OsString::from("/usr");
		}

		let mut msg = format!(
		"

		Could not find directory of OpenSSL installation, and this `-sys` crate cannot
		proceed without this knowledge. If OpenSSL is installed and this crate had
		trouble finding it, you can set the `OPENSSL_DIR` environment variable for the
		compilation process.

		Make sure you also have the development packages of openssl installed.
		For example, `libssl-dev` on Ubuntu or `openssl-devel` on Fedora.

		If you're in a situation where you think the directory should be found
		automatically, please open a bug at https://github.com/sfackler/rust-openssl
		and include information about your system as well as this message.

		$HOST = {}
		$TARGET = {}
		openssl-sys = {}

		",
		host,
		target,
		env!("CARGO_PKG_VERSION")
		);

		if host.contains("apple-darwin") && target.contains("apple-darwin") {
		let system = Path::new("/usr/lib/libssl.0.9.8.dylib");
		if system.exists() {
		msg.push_str(&format!(
		"

		It looks like you're compiling on macOS, where the system contains a version of
		OpenSSL 0.9.8. This crate no longer supports OpenSSL 0.9.8.

		As a consumer of this crate, you can fix this error by using Homebrew to
		install the `openssl` package, or as a maintainer you can use the openssl-sys
		0.7 crate for support with OpenSSL 0.9.8.

		Unfortunately though the compile cannot continue, so aborting.

		"
		));
		}
		}

		if host.contains("unknown-linux") && target.contains("unknown-linux-gnu") {
		if Command::new("pkg-config").output().is_err() {
		msg.push_str(&format!(
		"
		It looks like you're compiling on Linux and also targeting Linux. Currently this
		requires the `pkg-config` utility to find OpenSSL but unfortunately `pkg-config`
		could not be found. If you have OpenSSL installed you can likely fix this by
		installing `pkg-config`.

		"
		));
		}
		}

		if host.contains("windows") && target.contains("windows-gnu") {
		msg.push_str(&format!(
		"
		It looks like you're compiling for MinGW but you may not have either OpenSSL or
		pkg-config installed. You can install these two dependencies with:

		pacman -S openssl-devel pkg-config

		and try building this crate again.

		"
		));
		}

		if host.contains("windows") && target.contains("windows-msvc") {
		msg.push_str(&format!(
		"
		It looks like you're compiling for MSVC but we couldn't detect an OpenSSL
		installation. If there isn't one installed then you can try the rust-openssl
		README for more information about how to download precompiled binaries of
		OpenSSL:

		https://github.com/sfackler/rust-openssl#windows

		"
		));
		}

		panic!(msg);
		}

		/// Attempt to find OpenSSL through pkg-config.
		///
		/// Note that if this succeeds then the function does not return as pkg-config
		/// typically tells us all the information that we need.
		fn try_pkg_config() {
		let target = env::var("TARGET").unwrap();
		let host = env::var("HOST").unwrap();

		// If we're going to windows-gnu we can use pkg-config, but only so long as
		// we're coming from a windows host.
		//
		// Otherwise if we're going to windows we probably can't use pkg-config.
		if target.contains("windows-gnu") && host.contains("windows") {
		env::set_var("PKG_CONFIG_ALLOW_CROSS", "1");
		} else if target.contains("windows") {
		return;
		}

		let lib = match pkg_config::Config::new()
		.print_system_libs(false)
		.find("openssl")
		{
		Ok(lib) => lib,
		Err(e) => {
		println!("run pkg_config fail: {:?}", e);
		return;
		}
		};

		super::validate_headers(&lib.include_paths);

		for include in lib.include_paths.iter() {
		println!("cargo:include={}", include.display());
		}

		process::exit(0);
		}

		/// Attempt to find OpenSSL through vcpkg.
		///
		/// Note that if this succeeds then the function does not return as vcpkg
		/// should emit all of the cargo metadata that we need.
		#[cfg(target_env = "msvc")]
		fn try_vcpkg() {
		use vcpkg;

		// vcpkg will not emit any metadata if it can not find libraries
		// appropriate for the target triple with the desired linkage.

		let mut lib = vcpkg::Config::new()
		.emit_includes(true)
		.lib_name("libcrypto")
		.lib_name("libssl")
		.probe("openssl");

		if let Err(e) = lib {
		println!(
		"note: vcpkg did not find openssl as libcrypto and libssl : {:?}",
		e
		);
		lib = vcpkg::Config::new()
		.emit_includes(true)
		.lib_name("libeay32")
		.lib_name("ssleay32")
		.probe("openssl");
		}
		if let Err(e) = lib {
		println!(
		"note: vcpkg did not find openssl as ssleay32 and libeay32: {:?}",
		e
		);
		return;
		}

		let lib = lib.unwrap();
		super::validate_headers(&lib.include_paths);

		println!("cargo:rustc-link-lib=user32");
		println!("cargo:rustc-link-lib=gdi32");
		println!("cargo:rustc-link-lib=crypt32");

		process::exit(0);
		}

		#[cfg(not(target_env = "msvc"))]
		fn try_vcpkg() {}

		fn execute_command_and_get_output(cmd: &str, args: &[&str]) -> Option<String> {
		let out = Command::new(cmd).args(args).output();
		if let Ok(ref r1) = out {
		if r1.status.success() {
		let r2 = String::from_utf8(r1.stdout.clone());
		if let Ok(r3) = r2 {
		return Some(r3.trim().to_string());
		}
		}
		}
		return None;
		}
		}

		/// Validates the header files found in `include_dir` and then returns the
		/// version string of OpenSSL.
		fn validate_headers(include_dirs: &[PathBuf]) -> Version {
		@@ -385,50 +105,11 @@ fn validate_headers(include_dirs: &[PathBuf]) -> Version {
		// file of OpenSSL, `opensslconf.h`, and then dump out everything it defines
		// as our own #[cfg] directives. That way the `ossl10x.rs` bindings can
		// account for compile differences and such.
		let mut path = PathBuf::from(env::var_os("OUT_DIR").unwrap());
		path.push("expando.c");
		let mut file = BufWriter::new(File::create(&path).unwrap());

		write!(
		file,
		"\
		#include <openssl/opensslv.h>
		#include <openssl/opensslconf.h>

		#define VERSION2(n, v) RUST_VERSION_ ## n ## _ ## v
		#define VERSION(n, v) VERSION2(n, v)

		VERSION(OPENSSL, OPENSSL_VERSION_NUMBER)

		#ifdef LIBRESSL_VERSION_NUMBER
		VERSION(LIBRESSL, LIBRESSL_VERSION_NUMBER)
		#endif
		"
		)
		.unwrap();

		for define in DEFINES {
		write!(
		file,
		"\
		#ifdef {define}
		RUST_CONF_{define}
		#endif
		",
		define = define
		)
		.unwrap();
		}

		file.flush().unwrap();
		drop(file);

		let mut gcc = cc::Build::new();
		for include_dir in include_dirs {
		gcc.include(include_dir);
		}
		// https://github.com/alexcrichton/gcc-rs/issues/133
		let expanded = match gcc.file(&path).try_expand() {
		let expanded = match gcc.file("build/expando.c").try_expand() {
		Ok(expanded) => expanded,
		Err(e) => {
		panic!(