Files
ipass__ipass/rust/vendor/ngx-rust/nginx-src/src/lib.rs
T
admin 5c307ba1aa iPass 山海关:Rust 动态模块版全量入库
- vanilla nginx + Rust 动态模块(取代 OpenResty+Lua),共享内存为运行期真源
- 三域名分流 18098 ssl:mdm 管理台 / lm LLM 代理 / *.dm 企业转发,共用 *.mayishangshu.cn 通配符证书(证书不入库)
- LLM 统一出口:同 Key 鉴权、上游 Key 替换、白名单、限流配额、SSE
- 回归夹具 tests/(网关 55 + LLM 34 = 89 断言,夹具 cp 覆盖重置)
- 文档:readme(16 章)+ CLAUDE.md + conf/tls/README(acme.sh 证书管理、hairpin 环回链路)
2026-09-11 15:37:09 +08:00

215 lines
7.1 KiB
Rust

#![doc = include_str!("../README.md")]
#![warn(missing_docs)]
use std::ffi::OsString;
use std::path::{Path, PathBuf};
use std::process::Output;
use std::{env, io, thread};
mod download;
mod verifier;
static NGINX_DEFAULT_SOURCE_DIR: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/nginx");
const NGINX_BUILD_INFO: &str = "last-build-info";
const NGINX_BINARY: &str = "nginx";
static NGINX_CONFIGURE_BASE: &[&str] = &[
"--with-compat",
"--with-http_realip_module",
"--with-http_ssl_module",
"--with-http_v2_module",
"--with-mail",
"--with-mail_ssl_module",
"--with-stream",
"--with-stream_realip_module",
"--with-stream_ssl_module",
"--with-threads",
];
const ENV_VARS_TRIGGERING_RECOMPILE: [&str; 10] = [
"CACHE_DIR",
"CARGO_MANIFEST_DIR",
"CARGO_TARGET_TMPDIR",
"NGX_CONFIGURE_ARGS",
"NGX_CFLAGS",
"NGX_LDFLAGS",
"NGX_VERSION",
"OPENSSL_VERSION",
"PCRE2_VERSION",
"ZLIB_VERSION",
];
/*
###########################################################################
# NGINX Build Functions - Everything below here is for building NGINX #
###########################################################################
In order to build Rust bindings for NGINX using the bindgen crate, we need
to do the following:
1. Obtain a copy of the NGINX source code and the necessary dependencies:
OpenSSL, PCRE2, Zlib.
3. Run autoconf `configure` for NGINX.
4. Compile NGINX.
5. Read the autoconf generated makefile for NGINX and configure bindgen
to generate Rust bindings based on the includes in the makefile.
*/
/// Outputs cargo instructions required for using this crate from a buildscript.
pub fn print_cargo_metadata() {
for file in ["lib.rs", "download.rs", "verifier.rs"] {
println!("cargo::rerun-if-changed={path}/src/{file}", path = env!("CARGO_MANIFEST_DIR"))
}
for var in ENV_VARS_TRIGGERING_RECOMPILE {
println!("cargo::rerun-if-env-changed={var}");
}
}
/// Builds a copy of NGINX sources, either bundled with the crate or downloaded from the network.
pub fn build(build_dir: impl AsRef<Path>) -> io::Result<(PathBuf, PathBuf)> {
let source_dir = PathBuf::from(NGINX_DEFAULT_SOURCE_DIR);
let build_dir = build_dir.as_ref().to_owned();
let (source_dir, vendored_flags) = download::prepare(&source_dir, &build_dir)?;
let flags = nginx_configure_flags(&vendored_flags);
configure(&source_dir, &build_dir, &flags)?;
make(&source_dir, &build_dir, ["build"])?;
Ok((source_dir, build_dir))
}
/// Returns the options NGINX was built with
fn build_info(source_dir: &Path, configure_flags: &[String]) -> String {
// Flags should contain strings pointing to OS/platform as well as dependency versions,
// so if any of that changes, it can trigger a rebuild
format!("{:?}|{}", source_dir, configure_flags.join(" "))
}
/// Generate the flags to use with autoconf `configure` for NGINX.
fn nginx_configure_flags(vendored: &[String]) -> Vec<String> {
let mut nginx_opts: Vec<String> =
NGINX_CONFIGURE_BASE.iter().map(|x| String::from(*x)).collect();
nginx_opts.extend(vendored.iter().map(Into::into));
if let Ok(extra_args) = env::var("NGX_CONFIGURE_ARGS") {
// FIXME: shell style split?
nginx_opts.extend(extra_args.split_whitespace().map(Into::into));
}
if let Ok(cflags) = env::var("NGX_CFLAGS") {
nginx_opts.push(format!("--with-cc-opt={cflags}"));
}
if let Ok(ldflags) = env::var("NGX_LDFLAGS") {
nginx_opts.push(format!("--with-ld-opt={ldflags}"));
}
nginx_opts
}
/// Runs external process invoking autoconf `configure` for NGINX.
fn configure(source_dir: &Path, build_dir: &Path, flags: &[String]) -> io::Result<()> {
let build_info = build_info(source_dir, flags);
if build_dir.join("Makefile").is_file()
&& build_dir.join(NGINX_BINARY).is_file()
&& matches!(
std::fs::read_to_string(build_dir.join(NGINX_BUILD_INFO)).map(|x| x == build_info),
Ok(true)
)
{
println!("Build info unchanged, skipping configure");
return Ok(());
}
println!("Using NGINX source at {source_dir:?}");
let configure = ["configure", "auto/configure"]
.into_iter()
.map(|x| source_dir.join(x))
.find(|x| x.is_file())
.ok_or(io::ErrorKind::NotFound)?;
println!("Running NGINX configure script with flags: {:?}", flags.join(" "));
let mut build_dir_arg: OsString = "--builddir=".into();
build_dir_arg.push(build_dir);
let mut flags: Vec<OsString> = flags.iter().map(|x| x.into()).collect();
flags.push(build_dir_arg);
let output = duct::cmd(configure, flags).dir(source_dir).stderr_to_stdout().run()?;
if !output.status.success() {
println!("configure failed with {:?}", output.status);
return Err(io::ErrorKind::Other.into());
}
let _ = std::fs::write(build_dir.join(NGINX_BUILD_INFO), build_info);
Ok(())
}
/// Runs `make` within the NGINX source directory as an external process.
fn make<U>(source_dir: &Path, build_dir: &Path, extra_args: U) -> io::Result<Output>
where
U: IntoIterator,
U::Item: Into<OsString>,
{
// Level of concurrency to use when building nginx - cargo nicely provides this information
let num_jobs = match env::var("NUM_JOBS") {
Ok(s) => s.parse::<usize>().ok(),
Err(_) => thread::available_parallelism().ok().map(|n| n.get()),
}
.unwrap_or(1);
let mut args = vec![
OsString::from("-f"),
build_dir.join("Makefile").into(),
OsString::from("-j"),
num_jobs.to_string().into(),
];
args.extend(extra_args.into_iter().map(Into::into));
// Use MAKE passed from the parent process if set. Otherwise prefer `gmake` as it provides a
// better feature-wise implementation on some systems.
// Notably, we want to avoid SUN make on Solaris (does not support -j) or ancient GNU make 3.81
// on MacOS.
let inherited = env::var("MAKE");
let make_commands: &[&str] = match inherited {
Ok(ref x) => &[x.as_str(), "gmake", "make"],
_ => &["gmake", "make"],
};
// Give preference to the binary with the name of gmake if it exists because this is typically
// the GNU 4+ on MacOS (if it is installed via homebrew).
for make in make_commands {
/* Use the duct dependency here to merge the output of STDOUT and STDERR into a single stream,
and to provide the combined output as a reader which can be iterated over line-by-line. We
use duct to do this because it is a lot of work to implement this from scratch. */
let result = duct::cmd(*make, &args).dir(source_dir).stderr_to_stdout().run();
match result {
Err(err) if err.kind() == io::ErrorKind::NotFound => {
eprintln!("make: command '{make}' not found");
continue;
}
Ok(out) if !out.status.success() => {
return Err(io::Error::other(format!(
"make: '{}' failed with {:?}",
make, out.status
)));
}
_ => return result,
}
}
Err(io::ErrorKind::NotFound.into())
}