1extern crate cc;
2
3use std::env;
4use std::ffi::{OsStr, OsString};
5use std::fs;
6use std::path::{Path, PathBuf};
7use std::process::Command;
8
9pub fn source_dir() -> PathBuf {
10 Path::new(env!("CARGO_MANIFEST_DIR")).join("openssl")
11}
12
13pub fn version() -> &'static str {
14 env!("CARGO_PKG_VERSION")
15}
16
17pub struct Build {
18 out_dir: Option<PathBuf>,
19 target: Option<String>,
20 host: Option<String>,
21 openssl_dir: Option<PathBuf>,
23}
24
25pub struct Artifacts {
26 include_dir: PathBuf,
27 lib_dir: PathBuf,
28 bin_dir: PathBuf,
29 libs: Vec<String>,
30 target: String,
31}
32
33impl Build {
34 pub fn new() -> Build {
35 Build {
36 out_dir: env::var_os("OUT_DIR").map(|s| PathBuf::from(s).join("openssl-build")),
37 target: env::var("TARGET").ok(),
38 host: env::var("HOST").ok(),
39 openssl_dir: Some(PathBuf::from("/usr/local/ssl")),
40 }
41 }
42
43 pub fn out_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Build {
44 self.out_dir = Some(path.as_ref().to_path_buf());
45 self
46 }
47
48 pub fn target(&mut self, target: &str) -> &mut Build {
49 self.target = Some(target.to_string());
50 self
51 }
52
53 pub fn host(&mut self, host: &str) -> &mut Build {
54 self.host = Some(host.to_string());
55 self
56 }
57
58 pub fn openssl_dir<P: AsRef<Path>>(&mut self, path: P) -> &mut Build {
59 self.openssl_dir = Some(path.as_ref().to_path_buf());
60 self
61 }
62
63 fn cmd_make(&self) -> Result<Command, &'static str> {
64 let host = &self.host.as_ref().ok_or("HOST dir not set")?[..];
65 Ok(
66 if host.contains("dragonfly")
67 || host.contains("freebsd")
68 || host.contains("openbsd")
69 || host.contains("solaris")
70 || host.contains("illumos")
71 {
72 Command::new("gmake")
73 } else {
74 Command::new("make")
75 },
76 )
77 }
78
79 #[cfg(windows)]
80 fn check_env_var(&self, var_name: &str) -> Option<bool> {
81 env::var_os(var_name).and_then(|s| {
82 if s == "1" {
83 println!(
85 "cargo:warning={}: nasm.exe is force enabled by the \
86 'OPENSSL_RUST_USE_NASM' env var.",
87 env!("CARGO_PKG_NAME")
88 );
89 Some(true)
90 } else if s == "0" {
91 println!(
93 "cargo:warning={}: nasm.exe is force disabled by the \
94 'OPENSSL_RUST_USE_NASM' env var.",
95 env!("CARGO_PKG_NAME")
96 );
97 Some(false)
98 } else {
99 println!(
100 "cargo:warning=The environment variable {} is set to an unacceptable value: {:?}",
101 var_name, s
102 );
103 None
104 }
105 })
106 }
107
108 #[cfg(windows)]
109 fn is_nasm_ready(&self) -> bool {
110 self.check_env_var("OPENSSL_RUST_USE_NASM")
111 .unwrap_or_else(|| {
112 Command::new("cmd")
114 .args(&["/C", "where nasm"])
115 .output()
116 .map(|w| w.status.success())
117 .unwrap_or(false)
118 })
119 }
120
121 #[cfg(not(windows))]
122 fn is_nasm_ready(&self) -> bool {
123 false
125 }
126
127 pub fn build(&mut self) -> Artifacts {
129 match self.try_build() {
130 Ok(a) => a,
131 Err(e) => {
132 println!("cargo:warning=openssl-src: failed to build OpenSSL from source");
133 eprintln!("\n\n\n{e}\n\n\n");
134 std::process::exit(1);
135 }
136 }
137 }
138
139 pub fn try_build(&mut self) -> Result<Artifacts, String> {
140 let target = &self.target.as_ref().ok_or("TARGET dir not set")?[..];
141 let host = &self.host.as_ref().ok_or("HOST dir not set")?[..];
142 let out_dir = self.out_dir.as_ref().ok_or("OUT_DIR not set")?;
143 let build_dir = out_dir.join("build");
144 let install_dir = out_dir.join("install");
145
146 if build_dir.exists() {
147 fs::remove_dir_all(&build_dir).map_err(|e| format!("build_dir: {e}"))?;
148 }
149 if install_dir.exists() {
150 fs::remove_dir_all(&install_dir).map_err(|e| format!("install_dir: {e}"))?;
151 }
152
153 let inner_dir = build_dir.join("src");
154 fs::create_dir_all(&inner_dir).map_err(|e| format!("{}: {e}", inner_dir.display()))?;
155 cp_r(&source_dir(), &inner_dir)?;
156
157 let perl_program =
158 env::var("OPENSSL_SRC_PERL").unwrap_or(env::var("PERL").unwrap_or("perl".to_string()));
159 let mut configure = Command::new(perl_program);
160 configure.arg("./Configure");
161
162 if host.contains("pc-windows-gnu") {
164 configure.arg(&format!("--prefix={}", sanitize_sh(&install_dir)));
165 } else if host.contains("pc-windows-msvc") || host.contains("win7-windows-msvc") {
166 configure.arg(&format!(
171 "--prefix={}",
172 install_dir
173 .to_str()
174 .ok_or("bad install_dir")?
175 .replace("\\", "/")
176 ));
177 } else {
178 configure.arg(&format!("--prefix={}", install_dir.display()));
179 }
180
181 if target.contains("windows") {
186 configure.arg("--openssldir=SYS$MANAGER:[OPENSSL]");
187 } else {
188 let openssl_dir = self
189 .openssl_dir
190 .as_ref()
191 .ok_or("path to the openssl directory must be set")?;
192 let mut dir_arg: OsString = "--openssldir=".into();
193 dir_arg.push(openssl_dir);
194 configure.arg(dir_arg);
195 }
196
197 configure
198 .arg("no-shared")
200 .arg("no-module")
201 .arg("no-tests")
203 .arg("no-comp")
205 .arg("no-zlib")
206 .arg("no-zlib-dynamic")
207 .arg("--libdir=lib");
209
210 if cfg!(feature = "no-dso") {
211 if cfg!(feature = "force-engine") {
213 println!("Feature 'force-engine' requires DSO, ignoring 'no-dso' feature.");
214 } else {
215 configure.arg("no-dso");
216 }
217 }
218
219 if cfg!(not(feature = "legacy")) {
220 configure.arg("no-legacy");
221 }
222
223 if cfg!(feature = "ssl3") {
224 configure.arg("enable-ssl3").arg("enable-ssl3-method");
225 } else {
226 configure.arg("no-ssl3");
228 }
229
230 if cfg!(feature = "weak-crypto") {
231 configure
232 .arg("enable-md2")
233 .arg("enable-rc5")
234 .arg("enable-weak-ssl-ciphers");
235 } else {
236 configure
237 .arg("no-md2")
238 .arg("no-rc5")
239 .arg("no-weak-ssl-ciphers");
240 }
241
242 if cfg!(not(feature = "camellia")) {
243 configure.arg("no-camellia");
244 }
245
246 if cfg!(not(feature = "idea")) {
247 configure.arg("no-idea");
248 }
249
250 if cfg!(not(feature = "seed")) {
251 configure.arg("no-seed");
252 }
253
254 if cfg!(feature = "ktls") {
255 configure.arg("enable-ktls");
256 }
257
258 if target.contains("musl") {
259 if !cfg!(feature = "force-engine") {
263 configure.arg("no-engine");
264 }
265 } else if target.contains("windows") {
266 configure.arg("no-capieng");
271 }
272
273 if target.contains("musl") {
274 configure.arg("no-async");
277 }
278
279 if target.contains("android") {
283 configure.arg("no-stdio");
284 }
285
286 if target.contains("msvc") {
287 if self.is_nasm_ready() {
291 println!(
293 "{}: Enable the assembly language routines in building OpenSSL.",
294 env!("CARGO_PKG_NAME")
295 );
296 } else {
297 configure.arg("no-asm");
298 }
299 }
300
301 let os = match target {
302 "aarch64-apple-darwin" => "darwin64-arm64-cc",
303 "aarch64-linux-android" => "linux-aarch64",
309 "aarch64-unknown-freebsd" => "BSD-generic64",
310 "aarch64-unknown-openbsd" => "BSD-generic64",
311 "aarch64-unknown-linux-gnu" => "linux-aarch64",
312 "aarch64-unknown-linux-musl" => "linux-aarch64",
313 "aarch64-alpine-linux-musl" => "linux-aarch64",
314 "aarch64-chimera-linux-musl" => "linux-aarch64",
315 "aarch64-unknown-netbsd" => "BSD-generic64",
316 "aarch64_be-unknown-netbsd" => "BSD-generic64",
317 "aarch64-pc-windows-msvc" => "VC-WIN64-ARM",
318 "aarch64-uwp-windows-msvc" => "VC-WIN64-ARM-UWP",
319 "arm-linux-androideabi" => "linux-armv4",
320 "armv7-linux-androideabi" => "linux-armv4",
321 "arm-unknown-linux-gnueabi" => "linux-armv4",
322 "arm-unknown-linux-gnueabihf" => "linux-armv4",
323 "arm-unknown-linux-musleabi" => "linux-armv4",
324 "arm-unknown-linux-musleabihf" => "linux-armv4",
325 "arm-chimera-linux-musleabihf" => "linux-armv4",
326 "armv5te-unknown-linux-gnueabi" => "linux-armv4",
327 "armv5te-unknown-linux-musleabi" => "linux-armv4",
328 "armv6-unknown-freebsd" => "BSD-generic32",
329 "armv6-alpine-linux-musleabihf" => "linux-armv6",
330 "armv7-unknown-freebsd" => "BSD-armv4",
331 "armv7-unknown-linux-gnueabi" => "linux-armv4",
332 "armv7-unknown-linux-musleabi" => "linux-armv4",
333 "armv7-unknown-linux-gnueabihf" => "linux-armv4",
334 "armv7-unknown-linux-musleabihf" => "linux-armv4",
335 "armv7-alpine-linux-musleabihf" => "linux-armv4",
336 "armv7-chimera-linux-musleabihf" => "linux-armv4",
337 "armv7-unknown-netbsd-eabihf" => "BSD-generic32",
338 "asmjs-unknown-emscripten" => "gcc",
339 "i586-unknown-linux-gnu" => "linux-elf",
340 "i586-unknown-linux-musl" => "linux-elf",
341 "i586-alpine-linux-musl" => "linux-elf",
342 "i586-unknown-netbsd" => "BSD-x86-elf",
343 "i686-apple-darwin" => "darwin-i386-cc",
344 "i686-linux-android" => "linux-elf",
345 "i686-pc-windows-gnu" => "mingw",
346 "i686-pc-windows-msvc" => "VC-WIN32",
347 "i686-win7-windows-msvc" => "VC-WIN32",
348 "i686-unknown-freebsd" => "BSD-x86-elf",
349 "i686-unknown-haiku" => "haiku-x86",
350 "i686-unknown-linux-gnu" => "linux-elf",
351 "i686-unknown-linux-musl" => "linux-elf",
352 "i686-unknown-netbsd" => "BSD-x86-elf",
353 "i686-uwp-windows-msvc" => "VC-WIN32-UWP",
354 "loongarch64-unknown-linux-gnu" => "linux-generic64",
355 "loongarch64-unknown-linux-musl" => "linux-generic64",
356 "mips-unknown-linux-gnu" => "linux-mips32",
357 "mips-unknown-linux-musl" => "linux-mips32",
358 "mips64-unknown-linux-gnuabi64" => "linux64-mips64",
359 "mips64-unknown-linux-muslabi64" => "linux64-mips64",
360 "mips64el-unknown-linux-gnuabi64" => "linux64-mips64",
361 "mips64el-unknown-linux-muslabi64" => "linux64-mips64",
362 "mipsel-unknown-linux-gnu" => "linux-mips32",
363 "mipsel-unknown-linux-musl" => "linux-mips32",
364 "powerpc-unknown-freebsd" => "BSD-ppc",
365 "powerpc-unknown-linux-gnu" => "linux-ppc",
366 "powerpc-unknown-linux-gnuspe" => "linux-ppc",
367 "powerpc-chimera-linux-musl" => "linux-ppc",
368 "powerpc-unknown-netbsd" => "BSD-generic32",
369 "powerpc64-unknown-freebsd" => "BSD-ppc64",
370 "powerpc64-unknown-linux-gnu" => "linux-ppc64",
371 "powerpc64-unknown-linux-musl" => "linux-ppc64",
372 "powerpc64-chimera-linux-musl" => "linux-ppc64",
373 "powerpc64le-unknown-freebsd" => "BSD-ppc64le",
374 "powerpc64le-unknown-linux-gnu" => "linux-ppc64le",
375 "powerpc64le-unknown-linux-musl" => "linux-ppc64le",
376 "powerpc64le-alpine-linux-musl" => "linux-ppc64le",
377 "powerpc64le-chimera-linux-musl" => "linux-ppc64le",
378 "riscv64gc-unknown-freebsd" => "BSD-riscv64",
379 "riscv64gc-unknown-linux-gnu" => "linux64-riscv64",
380 "riscv64gc-unknown-linux-musl" => "linux64-riscv64",
381 "riscv64-alpine-linux-musl" => "linux64-riscv64",
382 "riscv64-chimera-linux-musl" => "linux64-riscv64",
383 "riscv64gc-unknown-netbsd" => "BSD-generic64",
384 "s390x-unknown-linux-gnu" => "linux64-s390x",
385 "sparc64-unknown-netbsd" => "BSD-generic64",
386 "s390x-unknown-linux-musl" => "linux64-s390x",
387 "s390x-alpine-linux-musl" => "linux64-s390x",
388 "sparcv9-sun-solaris" => "solaris64-sparcv9-gcc",
389 "thumbv7a-uwp-windows-msvc" => "VC-WIN32-ARM-UWP",
390 "x86_64-apple-darwin" => "darwin64-x86_64-cc",
391 "x86_64-linux-android" => "linux-x86_64",
392 "x86_64-linux" => "linux-x86_64",
393 "x86_64-pc-windows-gnu" => "mingw64",
394 "x86_64-pc-windows-gnullvm" => "mingw64",
395 "x86_64-pc-windows-msvc" => "VC-WIN64A",
396 "x86_64-win7-windows-msvc" => "VC-WIN64A",
397 "x86_64-unknown-freebsd" => "BSD-x86_64",
398 "x86_64-unknown-dragonfly" => "BSD-x86_64",
399 "x86_64-unknown-haiku" => "haiku-x86_64",
400 "x86_64-unknown-illumos" => "solaris64-x86_64-gcc",
401 "x86_64-unknown-linux-gnu" => "linux-x86_64",
402 "x86_64-unknown-linux-musl" => "linux-x86_64",
403 "x86_64-alpine-linux-musl" => "linux-x86_64",
404 "x86_64-chimera-linux-musl" => "linux-x86_64",
405 "x86_64-unknown-openbsd" => "BSD-x86_64",
406 "x86_64-unknown-netbsd" => "BSD-x86_64",
407 "x86_64-uwp-windows-msvc" => "VC-WIN64A-UWP",
408 "x86_64-pc-solaris" => "solaris64-x86_64-gcc",
409 "wasm32-unknown-emscripten" => "gcc",
410 "wasm32-unknown-unknown" => "gcc",
411 "wasm32-wasi" => "gcc",
412 "aarch64-apple-ios" => "ios64-cross",
413 "x86_64-apple-ios" => "iossimulator-xcrun",
414 "aarch64-apple-ios-sim" => "iossimulator-xcrun",
415 "aarch64-unknown-linux-ohos" => "linux-aarch64",
416 "armv7-unknown-linux-ohos" => "linux-generic32",
417 "x86_64-unknown-linux-ohos" => "linux-x86_64",
418 _ => {
419 return Err(format!(
420 "don't know how to configure OpenSSL for {}",
421 target
422 ))
423 }
424 };
425
426 let mut ios_isysroot: std::option::Option<String> = None;
427
428 configure.arg(os);
429
430 if !target.contains("msvc") {
434 let mut cc = cc::Build::new();
435 cc.target(target).host(host).warnings(false).opt_level(2);
436 let compiler = cc.get_compiler();
437 let mut cc_env = compiler.cc_env();
438 if cc_env.is_empty() {
439 cc_env = compiler.path().to_path_buf().into_os_string();
440 }
441 configure.env("CC", cc_env);
442 let path = compiler.path().to_str().ok_or("compiler path")?;
443
444 configure.env_remove("CROSS_COMPILE");
448
449 let ar = cc.get_archiver();
450 configure.env("AR", ar.get_program());
451 if ar.get_args().count() != 0 {
452 configure.env(
456 "ARFLAGS",
457 ar.get_args().collect::<Vec<_>>().join(OsStr::new(" ")),
458 );
459 }
460 let ranlib = cc.get_ranlib();
461 let mut args = vec![ranlib.get_program()];
463 args.extend(ranlib.get_args());
464 configure.env("RANLIB", args.join(OsStr::new(" ")));
465
466 let mut skip_next = false;
469 let mut is_isysroot = false;
470 for arg in compiler.args() {
471 if target.contains("musl") && arg == "-static" {
474 continue;
475 }
476
477 if target.contains("apple") {
481 if arg == "-arch" {
482 skip_next = true;
483 continue;
484 }
485 }
486
487 if target.contains("apple-ios") {
489 if arg == "-isysroot" {
490 is_isysroot = true;
491 continue;
492 }
493
494 if is_isysroot {
495 is_isysroot = false;
496 ios_isysroot = Some(arg.to_str().ok_or("isysroot arg")?.to_string());
497 continue;
498 }
499 }
500
501 if skip_next {
502 skip_next = false;
503 continue;
504 }
505
506 configure.arg(arg);
507 }
508
509 if os.contains("iossimulator") {
510 if let Some(ref isysr) = ios_isysroot {
511 configure.env(
512 "CC",
513 &format!(
514 "xcrun -sdk iphonesimulator cc -isysroot {}",
515 sanitize_sh(&Path::new(isysr))
516 ),
517 );
518 }
519 }
520
521 if target == "x86_64-pc-windows-gnu" {
522 configure.arg("-Wa,-mbig-obj");
537 }
538
539 if target.contains("pc-windows-gnu") && path.ends_with("-gcc") {
540 let windres = format!("{}-windres", &path[..path.len() - 4]);
545 configure.env("WINDRES", &windres);
546 }
547
548 if target.contains("emscripten") {
549 configure.arg("-D__STDC_NO_ATOMICS__");
556 }
557
558 if target.contains("wasi") {
559 configure.args([
560 "no-ui-console",
562 "no-sock",
564 "-DNO_SYSLOG",
566 "no-threads",
568 "no-asm",
570 "no-afalgeng",
574 "-DOPENSSL_NO_AFALGENG=1",
575 "-D_WASI_EMULATED_SIGNAL",
579 "-D_WASI_EMULATED_PROCESS_CLOCKS",
584 "-D_WASI_EMULATED_MMAN",
588 "-D_WASI_EMULATED_GETPID",
593 "-DNO_CHMOD",
595 ]);
596 }
597
598 if target.contains("musl") {
599 configure.arg("-DOPENSSL_NO_SECURE_MEMORY");
601 }
602 }
603
604 configure.current_dir(&inner_dir);
606 self.run_command(configure, "configuring OpenSSL build")?;
607
608 if target.contains("msvc") {
611 let mut build =
612 cc::windows_registry::find(target, "nmake.exe").ok_or("failed to find nmake")?;
613 build.arg("build_libs").current_dir(&inner_dir);
614 self.run_command(build, "building OpenSSL")?;
615
616 let mut install =
617 cc::windows_registry::find(target, "nmake.exe").ok_or("failed to find nmake")?;
618 install.arg("install_dev").current_dir(&inner_dir);
619 self.run_command(install, "installing OpenSSL")?;
620 } else {
621 let mut depend = self.cmd_make()?;
622 depend.arg("depend").current_dir(&inner_dir);
623 self.run_command(depend, "building OpenSSL dependencies")?;
624
625 let mut build = self.cmd_make()?;
626 build.arg("build_libs").current_dir(&inner_dir);
627 if !cfg!(windows) {
628 if let Some(s) = env::var_os("CARGO_MAKEFLAGS") {
629 build.env("MAKEFLAGS", s);
630 }
631 }
632
633 if let Some(ref isysr) = ios_isysroot {
634 let components: Vec<&str> = isysr.split("/SDKs/").collect();
635 build.env("CROSS_TOP", components[0]);
636 build.env("CROSS_SDK", components[1]);
637 }
638
639 self.run_command(build, "building OpenSSL")?;
640
641 let mut install = self.cmd_make()?;
642 install.arg("install_dev").current_dir(&inner_dir);
643 self.run_command(install, "installing OpenSSL")?;
644 }
645
646 let libs = if target.contains("msvc") {
647 vec!["libssl".to_string(), "libcrypto".to_string()]
648 } else {
649 vec!["ssl".to_string(), "crypto".to_string()]
650 };
651
652 fs::remove_dir_all(&inner_dir).map_err(|e| format!("{}: {e}", inner_dir.display()))?;
653
654 Ok(Artifacts {
655 lib_dir: install_dir.join("lib"),
656 bin_dir: install_dir.join("bin"),
657 include_dir: install_dir.join("include"),
658 libs: libs,
659 target: target.to_string(),
660 })
661 }
662
663 #[track_caller]
664 fn run_command(&self, mut command: Command, desc: &str) -> Result<(), String> {
665 println!("running {:?}", command);
666 let status = command.status();
667
668 let verbose_error = match status {
669 Ok(status) if status.success() => return Ok(()),
670 Ok(status) => format!(
671 "'{exe}' reported failure with {status}",
672 exe = command.get_program().to_string_lossy()
673 ),
674 Err(failed) => match failed.kind() {
675 std::io::ErrorKind::NotFound => format!(
676 "Command '{exe}' not found. Is {exe} installed?",
677 exe = command.get_program().to_string_lossy()
678 ),
679 _ => format!(
680 "Could not run '{exe}', because {failed}",
681 exe = command.get_program().to_string_lossy()
682 ),
683 },
684 };
685 println!("cargo:warning={desc}: {verbose_error}");
686 Err(format!(
687 "Error {desc}:
688 {verbose_error}
689 Command failed: {command:?}"
690 ))
691 }
692}
693
694fn cp_r(src: &Path, dst: &Path) -> Result<(), String> {
695 for f in fs::read_dir(src).map_err(|e| format!("{}: {e}", src.display()))? {
696 let f = match f {
697 Ok(f) => f,
698 _ => continue,
699 };
700 let path = f.path();
701 let name = path
702 .file_name()
703 .ok_or_else(|| format!("bad dir {}", src.display()))?;
704
705 if name.to_str() == Some(".git") {
708 continue;
709 }
710
711 let dst = dst.join(name);
712 let ty = f.file_type().map_err(|e| e.to_string())?;
713 if ty.is_dir() {
714 fs::create_dir_all(&dst).map_err(|e| e.to_string())?;
715 cp_r(&path, &dst)?;
716 } else if ty.is_symlink() && path.iter().any(|p| p == "cloudflare-quiche") {
717 continue;
719 } else {
720 let _ = fs::remove_file(&dst);
721 if let Err(e) = fs::copy(&path, &dst) {
722 return Err(format!(
723 "failed to copy '{}' to '{}': {e}",
724 path.display(),
725 dst.display()
726 ));
727 }
728 }
729 }
730 Ok(())
731}
732
733fn sanitize_sh(path: &Path) -> String {
734 if !cfg!(windows) {
735 return path.to_string_lossy().into_owned();
736 }
737 let path = path.to_string_lossy().replace("\\", "/");
738 return change_drive(&path).unwrap_or(path);
739
740 fn change_drive(s: &str) -> Option<String> {
741 let mut ch = s.chars();
742 let drive = ch.next().unwrap_or('C');
743 if ch.next() != Some(':') {
744 return None;
745 }
746 if ch.next() != Some('/') {
747 return None;
748 }
749 Some(format!("/{}/{}", drive, &s[drive.len_utf8() + 2..]))
750 }
751}
752
753impl Artifacts {
754 pub fn include_dir(&self) -> &Path {
755 &self.include_dir
756 }
757
758 pub fn lib_dir(&self) -> &Path {
759 &self.lib_dir
760 }
761
762 pub fn libs(&self) -> &[String] {
763 &self.libs
764 }
765
766 pub fn print_cargo_metadata(&self) {
767 println!("cargo:rustc-link-search=native={}", self.lib_dir.display());
768 for lib in self.libs.iter() {
769 println!("cargo:rustc-link-lib=static={}", lib);
770 }
771 println!("cargo:include={}", self.include_dir.display());
772 println!("cargo:lib={}", self.lib_dir.display());
773 if self.target.contains("windows") {
774 println!("cargo:rustc-link-lib=user32");
775 println!("cargo:rustc-link-lib=crypt32");
776 println!("cargo:rustc-link-lib=advapi32");
777 } else if self.target == "wasm32-wasi" {
778 println!("cargo:rustc-link-lib=wasi-emulated-signal");
779 println!("cargo:rustc-link-lib=wasi-emulated-process-clocks");
780 println!("cargo:rustc-link-lib=wasi-emulated-mman");
781 println!("cargo:rustc-link-lib=wasi-emulated-getpid");
782 }
783 }
784}