1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
extern crate pkg_config;
use std::env;
use std::fs;
use std::path::PathBuf;
use std::process::Command;
macro_rules! t {
($e:expr) => (match $e {
Ok(n) => n,
Err(e) => panic!("\n{} failed with {}\n", stringify!($e), e),
})
}
fn main() {
match pkg_config::find_library("libssh2") {
Ok(..) => return,
Err(..) => {}
}
let mut cflags = env::var("CFLAGS").unwrap_or(String::new());
let target = env::var("TARGET").unwrap();
let windows = target.contains("windows") || target.contains("mingw");
cflags.push_str(" -ffunction-sections -fdata-sections");
if target.contains("i686") {
cflags.push_str(" -m32");
} else if target.contains("x86_64") {
cflags.push_str(" -m64");
}
if !target.contains("i686") {
cflags.push_str(" -fPIC");
}
match env::var("DEP_OPENSSL_ROOT") {
Ok(s) => {
cflags.push_str(&format!(" -I{}/include", s));
cflags.push_str(&format!(" -L{}/lib", s));
}
Err(..) => {}
}
let src = PathBuf::from(&env::var_os("CARGO_MANIFEST_DIR").unwrap());
let dst = PathBuf::from(&env::var_os("OUT_DIR").unwrap());
let mut config_opts = Vec::new();
if windows {
config_opts.push("--without-openssl".to_string());
config_opts.push("--with-wincng".to_string());
}
config_opts.push("--enable-shared=no".to_string());
config_opts.push("--disable-examples-build".to_string());
config_opts.push(format!("--prefix={}", dst.display()));
let _ = fs::remove_dir_all(&dst.join("include"));
let _ = fs::remove_dir_all(&dst.join("lib"));
let _ = fs::remove_dir_all(&dst.join("build"));
t!(fs::create_dir(&dst.join("build")));
let root = src.join("libssh2-1.5.0");
// Can't run ./configure directly on msys2 b/c we're handing in
// Windows-style paths (those starting with C:\), but it chokes on those.
// For that reason we build up a shell script with paths converted to
// posix versions hopefully...
//
// Also apparently the buildbots choke unless we manually set LD, who knows
// why?!
run(Command::new("sh")
.env("CFLAGS", &cflags)
.env("LD", &which("ld").unwrap())
.current_dir(&dst.join("build"))
.arg("-c")
.arg(&format!("{} {}", root.join("configure").display(),
config_opts.connect(" "))
.replace("C:\\", "/c/")
.replace("\\", "/")));
run(Command::new(&make())
.arg(&format!("-j{}", env::var("NUM_JOBS").unwrap()))
.current_dir(&dst.join("build/src")));
// Don't run `make install` because apparently it's a little buggy on mingw
// for windows.
t!(fs::create_dir_all(&dst.join("lib/pkgconfig")));
// Which one does windows generate? Who knows!
let p1 = dst.join("build/src/.libs/libssh2.a");
let p2 = dst.join("build/src/.libs/libssh2.lib");
if fs::metadata(&p1).is_ok() {
t!(fs::copy(&p1, &dst.join("lib/libssh2.a")));
} else {
t!(fs::copy(&p2, &dst.join("lib/libssh2.a")));
}
t!(fs::rename(&dst.join("build/libssh2.pc"),
&dst.join("lib/pkgconfig/libssh2.pc")));
{
let root = root.join("include");
let dst = dst.join("include");
t!(fs::create_dir_all(&dst));
t!(fs::copy(&root.join("libssh2.h"), &dst.join("libssh2.h")));
t!(fs::copy(&root.join("libssh2_publickey.h"),
&dst.join("libssh2_publickey.h")));
t!(fs::copy(&root.join("libssh2_sftp.h"), &dst.join("libssh2_sftp.h")));
}
if windows {
println!("cargo:rustc-link-lib=ws2_32");
println!("cargo:rustc-link-lib=bcrypt");
println!("cargo:rustc-link-lib=crypt32");
}
println!("cargo:rustc-link-search=native={}/lib", dst.display());
println!("cargo:rustc-link-lib=static=ssh2");
println!("cargo:root={}", dst.display());
println!("cargo:include={}/include", dst.display());
}
fn make() -> &'static str {
if cfg!(target_os = "freebsd") {"gmake"} else {"make"}
}
fn run(cmd: &mut Command) {
println!("running: {:?}", cmd);
assert!(t!(cmd.status()).success());
}
fn which(cmd: &str) -> Option<PathBuf> {
let cmd = format!("{}{}", cmd, env::consts::EXE_SUFFIX);
env::split_paths(&env::var("PATH").unwrap()).map(|p| {
p.join(&cmd)
}).find(|p| fs::metadata(p).is_ok())
}
|
