Files
ipass__ipass/rust/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

689 lines
25 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
//! iPass 山海关(ipass-gateway)—— nginx + Rust 动态模块(v2)
//!
//! 公司统一动态域名解析出口。本模块承担原 OpenResty + Lua 版的**全部**职责:
//!
//! | 旧版(Lua) | 新版(Rust) |
//! |------------------------------------|-------------------------|
//! | `lua_shared_dict proxy_cache` | `state` 共享内存映射表 |
//! | `lua_shared_dict admin_sessions` | `state` 会话键 |
//! | `lua_shared_dict lua_locks` | `state` 文件写锁 |
//! | `store.lua`(cjson + resty.lock) | `store` + serde_json |
//! | `users.lua` / `domains.lua` | `users` / `domains` |
//! | `api.lua` 路由表 | `api` 精确匹配路由表 |
//! | `proxy.lua` 转发热路径 | `ResolveHandler` |
//! | —(新增能力) | `LlmHandler` LLM 代理 |
//!
//! ## 三条热路径
//!
//! | 入口 | 阶段 | 开关 | 做什么 |
//! | --- | --- | --- | --- |
//! | `*.yourdomain.com/*` | access | `ipass_proxy` | 查 `sub:` 决定后端 |
//! | `llm.yourdomain.com/<slot>/*` | access | `ipass_llm` | 查 `ukey:` 鉴权 + `up:` 定上游 |
//! | `proxy-api.yourdomain.com/api/*` | content | `ipass_api` | 管理接口,读体后分发 |
//!
//! ## 关键实现约束(均为实测/查证确认,详见 CLAUDE.md)
//!
//! * `ngx_http_add_variable` 必须在 **preconfiguration** 阶段调用,
//! 否则配置里的 `proxy_pass http://$proxy_backend_addr` 无法解析。
//! * 阶段处理器在 postconfiguration 阶段注册,且**必须按 location 开关**
//! (`ipass_proxy` / `ipass_api` / `ipass_llm`),否则管理台与 API
//! 也会被转发逻辑 404 掉。
//! * 共享内存只有 `RwLock<RbTreeMap<_, _, SlabPool>, _>` 一种安全形态;
//! `SlabPool` 只能在 zone 初始化回调里取出,锁本身也必须用
//! `ngx::allocator::allocate` 放进共享内存,否则各 worker 拿到的是各自的副本。
//! * ngx crate **没有**暴露请求体读取,必须走
//! `ngx_http_read_client_request_body` 的两段式异步接口(见 `ApiHandler`)。
//! **这也是 LLM 代理不按 body 里的 `model` 字段路由的原因**——access 阶段
//! 根本拿不到请求体。
mod api;
mod config;
mod domains;
mod http;
mod llm;
mod models;
mod session;
mod state;
mod store;
mod upstreams;
mod util;
mod users;
use core::ffi::{c_char, c_void};
use core::ptr;
use core::sync::atomic::{AtomicUsize, Ordering};
use ngx::core::{NGX_CONF_ERROR, NGX_CONF_OK, NgxStr, NgxString, Pool, SlabPool, Status};
use ngx::ffi::{
NGX_CONF_TAKE1, NGX_CONF_TAKE2, NGX_HTTP_LOC_CONF, NGX_HTTP_LOC_CONF_OFFSET, NGX_HTTP_MAIN_CONF,
NGX_HTTP_MAIN_CONF_OFFSET, NGX_HTTP_MODULE, NGX_HTTP_VAR_CHANGEABLE, NGX_HTTP_VAR_NOCACHEABLE,
NGX_LOG_EMERG, ngx_command_t, ngx_conf_t, ngx_cycle_t, ngx_http_add_variable,
ngx_http_get_variable_index, ngx_http_module_t, ngx_http_request_t,
ngx_http_variable_value_t, ngx_int_t, ngx_module_t, ngx_parse_size, ngx_shared_memory_add,
ngx_shm_zone_t, ngx_str_t, ngx_uint_t,
};
use ngx::http::{
HTTPStatus, HttpModule, HttpModuleLocationConf, HttpPhase, HttpRequestHandler, Merge,
MergeConfigError,
};
use ngx::{ngx_conf_log_error, ngx_string};
/// `$proxy_backend_addr` 在 `r->variables` 里的下标
static BACKEND_VAR_INDEX: AtomicUsize = AtomicUsize::new(usize::MAX);
// ===========================================================================
// 转发热路径
// ===========================================================================
/// 查共享内存取后端地址;已过期的条目视为不存在。
///
/// **热路径唯一入口**——只读内存,未命中不产生任何 I/O。
/// 旧版这里在 miss 时会去读 `domains.json` 并全量 JSON 解码,
/// 那正是「随便发一堆随机子域名就能打穿磁盘」的入口。
fn resolve_backend(subdomain: &[u8]) -> Option<String> {
let (backend, expires_at) = state::get_backend(subdomain)?;
if expires_at > 0 && expires_at <= util::now() {
return None;
}
Some(backend)
}
/// 取 Host 头里第一个点之前的部分作为子域名。
///
/// 刻意不走 nginx 的 server_name 正则捕获变量(那需要再算一次变量 hash),
/// 热路径上手工切更省。
fn subdomain_of(r: *mut ngx_http_request_t) -> Option<Vec<u8>> {
// SAFETY: r 有效;迭代器只在本函数存续期内使用
let request = unsafe { ngx::http::Request::from_ngx_http_request(r) };
for (key, value) in request.headers_in_iterator() {
if key.as_bytes().eq_ignore_ascii_case(b"host") {
let host = value.as_bytes();
// 去掉端口
let host = match host.iter().position(|&b| b == b':') {
Some(i) => &host[..i],
None => host,
};
// 取第一段标签
let label = match host.iter().position(|&b| b == b'.') {
Some(i) => &host[..i],
None => host,
};
if label.is_empty() {
return None;
}
return Some(label.to_ascii_lowercase());
}
}
None
}
/// 把后端地址写进 `r->variables[$proxy_backend_addr]`,供 `proxy_pass` 使用
fn set_backend_var(r: *mut ngx_http_request_t, backend: &str) {
let idx = BACKEND_VAR_INDEX.load(Ordering::SeqCst);
if idx == usize::MAX {
return;
}
// SAFETY: idx 由 ngx_http_get_variable_index 分配且落在 r->variables 内;
// 值分配在请求池里,随请求回收
unsafe {
let pool = Pool::from_ngx_pool((*r).pool);
let bytes = backend.as_bytes();
let data = pool.alloc(bytes.len()) as *mut u8;
if data.is_null() {
return;
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data, bytes.len());
let vv: *mut ngx_http_variable_value_t = (*r).variables.add(idx);
(*vv).data = data;
(*vv).set_len(bytes.len() as _);
(*vv).set_valid(1);
(*vv).set_not_found(0);
(*vv).set_no_cacheable(1);
}
}
/// 变量 get_handler:`proxy_pass` 求值 `$proxy_backend_addr` 时被调用。
///
/// 与 access 阶段互补——这里保证「即使 access 未赋值也能取到」,
/// access 阶段则负责决定命中不了时返回 404。
extern "C" fn backend_get(
r: *mut ngx_http_request_t,
v: *mut ngx_http_variable_value_t,
_data: usize,
) -> ngx_int_t {
// SAFETY: nginx 传入的 r/v 必然有效
unsafe {
let resolved = subdomain_of(r).as_deref().and_then(resolve_backend);
let Some(backend) = resolved else {
(*v).set_not_found(1);
return Status::NGX_ERROR.into();
};
let pool = Pool::from_ngx_pool((*r).pool);
let bytes = backend.as_bytes();
let data = pool.alloc(bytes.len()) as *mut u8;
if data.is_null() {
(*v).set_not_found(1);
return Status::NGX_ERROR.into();
}
ptr::copy_nonoverlapping(bytes.as_ptr(), data, bytes.len());
(*v).data = data;
(*v).set_len(bytes.len() as _);
(*v).set_valid(1);
(*v).set_no_cacheable(1);
(*v).set_not_found(0);
Status::NGX_OK.into()
}
}
// ===========================================================================
// 阶段处理器
// ===========================================================================
/// 转发热路径:命中则放行(`proxy_pass` 会去取 `$proxy_backend_addr`),未命中直接 404。
struct ResolveHandler;
impl HttpRequestHandler for ResolveHandler {
const PHASE: HttpPhase = HttpPhase::Access;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
// 未开启该开关的 location 一律放行(管理台/API 走这里)
if !Module::location_conf(request).map(|c| c.proxy).unwrap_or(false) {
return Status::NGX_DECLINED;
}
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
let Some(host) = subdomain_of(r) else {
return HTTPStatus::NOT_FOUND.into();
};
match resolve_backend(&host) {
Some(backend) => {
set_backend_var(r, &backend);
Status::NGX_DECLINED
}
// 与旧版语义一致:查不到 = 未配置 / 已过期 / 已删除 / 尚未审核通过
None => HTTPStatus::NOT_FOUND.into(),
}
}
}
/// LLM 代理热路径:鉴权 → 校验上游与白名单 → 放行。
///
/// 刻意**只做决策、不搬数据**:真正的转发交给 nginx 的 proxy 模块,
/// 于是 SSE 流式、`proxy_buffering`、上游超时全部是 nginx 原生行为,
/// 不需要自己实现 upstream——那正是「按 body 里的 model 路由」代价高昂之处。
///
/// 变量(`$llm_target` / `$llm_host` / `$llm_auth`)不在这里赋值,
/// 而由 `llm::var_get` 在 `proxy_pass` 求值时计算,与 `$proxy_backend_addr` 同构。
struct LlmHandler;
impl HttpRequestHandler for LlmHandler {
const PHASE: HttpPhase = HttpPhase::Access;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
if !Module::location_conf(request).map(|c| c.llm).unwrap_or(false) {
return Status::NGX_DECLINED;
}
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
let Some(slot) = llm::slot_of(r) else {
return llm::fail(
r,
HTTPStatus::BAD_REQUEST,
"invalid_request_error",
"路径缺少上游段,正确形式:/<上游名>/v1/chat/completions",
);
};
let Some(key) = llm::downstream_key(r) else {
return llm::fail(
r,
HTTPStatus::UNAUTHORIZED,
"invalid_api_key",
"缺少 API Key,请在 Authorization: Bearer 或 x-api-key 中携带",
);
};
// 只碰共享内存:这里若改成 users::find_by_key 会每请求读一次 users.json
let Some((username, allowed, rpm, daily)) = llm::identity(&key) else {
util::log_warn(&format!(
"[llm] API Key 校验失败 slot={slot} client={}",
http::remote_addr(r)
));
return llm::fail(
r,
HTTPStatus::UNAUTHORIZED,
"invalid_api_key",
"API Key 无效或已失效",
);
};
if state::get_upstream(&slot).is_none() {
return llm::fail(
r,
HTTPStatus::NOT_FOUND,
"model_not_found",
&format!("上游 {slot} 不存在或已停用"),
);
}
// 空白名单 = 不限(老账号没有该字段时的语义)
if !allowed.is_empty() && !allowed.iter().any(|s| s == &slot) {
util::log_warn(&format!("[llm] {username} 无权访问上游 {slot}"));
return llm::fail(
r,
HTTPStatus::FORBIDDEN,
"permission_denied",
&format!("当前账号无权访问上游 {slot}"),
);
}
// 限流与每日配额(先增后判,纯共享内存)。放在最后:
// 鉴权/白名单都没过的请求不该消耗对方的计数
// SAFETY: r 由 nginx 传入且有效
if let Some(resp) = unsafe { llm::check_quota(r, &username, rpm, daily) } {
return resp;
}
Status::NGX_DECLINED
}
}
/// 管理 API:content 阶段先读请求体,读完后交给 `api::dispatch`。
///
/// 这是本项目唯一需要异步的地方。`ngx_http_read_client_request_body` 是
/// **两段式**接口:请求体已在缓冲区时会**同步**调用 post_handler,
/// 否则挂起等 socket 事件后回调。两条路径都必须正确,所以不能假设
/// 「回调一定晚于本次返回」。
struct ApiHandler;
impl HttpRequestHandler for ApiHandler {
const PHASE: HttpPhase = HttpPhase::Content;
type Output = Status;
fn handler(request: &mut ngx::http::Request) -> Self::Output {
if !Module::location_conf(request).map(|c| c.api).unwrap_or(false) {
return Status::NGX_DECLINED;
}
let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t;
// SAFETY: r 有效;回调只会在请求内存池存活期间被调用
let rc = unsafe { nginx_sys::ngx_http_read_client_request_body(r, Some(api_body_ready)) };
// 读体失败(请求体超限等):把原始状态码交回 nginx,由它生成对应错误页
if rc >= nginx_sys::NGX_HTTP_SPECIAL_RESPONSE as ngx_int_t {
return Status(rc);
}
// 响应由回调发出,本阶段到此挂起
Status::NGX_DONE
}
}
/// 请求体就绪回调:执行路由分发并终结请求。
unsafe extern "C" fn api_body_ready(r: *mut ngx_http_request_t) {
let status = api::dispatch(r);
// SAFETY: r 由 nginx 传入且仍然有效;NGX_OK 表示响应已完整发出
unsafe { nginx_sys::ngx_http_finalize_request(r, status.0) };
}
// ===========================================================================
// 模块定义
// ===========================================================================
struct Module;
/// 按 location 生效的开关。
///
/// 必须存在:阶段处理器注册在 http 主配置上,若不按 location 收敛,
/// 管理台与 API 也会走转发逻辑并被 404。
#[derive(Debug, Default)]
struct ModuleConfig {
/// 该 location 走「子域名 → 后端」转发
proxy: bool,
/// 该 location 暴露管理 API(/api/admin/*、/api/v1/*)
api: bool,
/// 该 location 走 LLM 代理(`/<slot>/...` → 上游)
llm: bool,
}
unsafe impl HttpModuleLocationConf for Module {
type LocationConf = ModuleConfig;
}
impl Merge for ModuleConfig {
fn merge(&mut self, prev: &ModuleConfig) -> Result<(), MergeConfigError> {
if prev.proxy {
self.proxy = true;
}
if prev.api {
self.api = true;
}
if prev.llm {
self.llm = true;
}
Ok(())
}
}
/// 注册一个只读变量,值由 `llm::var_get` 按 `slot` 分派计算。
///
/// 与 `$proxy_backend_addr` 不同,LLM 三件套**不需要**
/// `ngx_http_get_variable_index`——它们是纯只读的,模块从不主动写,
/// 只有 `proxy_pass` / `proxy_set_header` 求值时触发 get_handler。
unsafe fn add_llm_var(cf: *mut ngx_conf_t, name: *mut ngx_str_t, slot: usize) -> bool {
// SAFETY: cf 由 nginx 传入;name 指向本函数调用方栈上的 ngx_str_t,注册时被拷贝
let var = unsafe {
ngx_http_add_variable(
cf,
name,
(NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE) as ngx_uint_t,
)
};
if var.is_null() {
return false;
}
// SAFETY: var 非空且由本函数独占初始化;data 承载分派标记
unsafe {
(*var).get_handler = Some(llm::var_get);
(*var).set_handler = None;
(*var).data = slot;
}
true
}
impl HttpModule for Module {
fn module() -> &'static ngx_module_t {
// SAFETY: 模块定义是静态的,生命周期贯穿进程
unsafe { &*ptr::addr_of!(ngx_http_ipass_module) }
}
/// 必须在配置解析前注册变量,否则 `proxy_pass http://$proxy_backend_addr` 无法解析
unsafe extern "C" fn preconfiguration(cf: *mut ngx_conf_t) -> ngx_int_t {
let mut name = ngx_string!("proxy_backend_addr");
let idx = unsafe { ngx_http_get_variable_index(cf, &raw mut name) };
if idx == -1 {
return Status::NGX_ERROR.into();
}
BACKEND_VAR_INDEX.store(idx as usize, Ordering::SeqCst);
let var = unsafe {
ngx_http_add_variable(
cf,
&raw mut name,
(NGX_HTTP_VAR_CHANGEABLE | NGX_HTTP_VAR_NOCACHEABLE) as ngx_uint_t,
)
};
if var.is_null() {
return Status::NGX_ERROR.into();
}
// SAFETY: var 非空且由本函数独占初始化
unsafe {
(*var).get_handler = Some(backend_get);
(*var).set_handler = None;
(*var).data = 0;
}
// LLM 三件套。名字里的 `llm_` 前缀不要省:nginx 变量名全局唯一,
// 将来接入别的模块时才不会撞名。
let mut target = ngx_string!("llm_target");
let mut host = ngx_string!("llm_host");
let mut auth = ngx_string!("llm_auth");
let llm_ok = unsafe {
add_llm_var(cf, &raw mut target, llm::VAR_TARGET)
&& add_llm_var(cf, &raw mut host, llm::VAR_HOST)
&& add_llm_var(cf, &raw mut auth, llm::VAR_AUTH)
};
if !llm_ok {
ngx_conf_log_error!(NGX_LOG_EMERG, unsafe { &mut *cf }, "注册 LLM 变量失败");
return Status::NGX_ERROR.into();
}
Status::NGX_OK.into()
}
unsafe extern "C" fn postconfiguration(cf: *mut ngx_conf_t) -> ngx_int_t {
let cf = unsafe { &mut *cf };
if ngx::http::add_phase_handler::<ResolveHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
if ngx::http::add_phase_handler::<LlmHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
if ngx::http::add_phase_handler::<ApiHandler>(cf).is_err() {
return Status::NGX_ERROR.into();
}
Status::NGX_OK.into()
}
}
static mut NGX_HTTP_IPASS_COMMANDS: [ngx_command_t; 6] = [
ngx_command_t {
name: ngx_string!("ipass_state"),
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE2) as ngx_uint_t,
set: Some(set_state_zone),
conf: NGX_HTTP_MAIN_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_data_dir"),
type_: (NGX_HTTP_MAIN_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_data_dir),
conf: NGX_HTTP_MAIN_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_proxy"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_flag_proxy),
conf: NGX_HTTP_LOC_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_api"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_flag_api),
conf: NGX_HTTP_LOC_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t {
name: ngx_string!("ipass_llm"),
type_: (NGX_HTTP_LOC_CONF | NGX_CONF_TAKE1) as ngx_uint_t,
set: Some(set_flag_llm),
conf: NGX_HTTP_LOC_CONF_OFFSET,
offset: 0,
post: ptr::null_mut(),
},
ngx_command_t::empty(),
];
static NGX_HTTP_IPASS_MODULE_CTX: ngx_http_module_t = ngx_http_module_t {
preconfiguration: Some(Module::preconfiguration),
postconfiguration: Some(Module::postconfiguration),
create_main_conf: None,
init_main_conf: None,
create_srv_conf: None,
merge_srv_conf: None,
create_loc_conf: Some(Module::create_loc_conf),
merge_loc_conf: Some(Module::merge_loc_conf),
};
// 脱离 nginx 构建系统、单独产出 cdylib 时必须靠这个宏导出 ngx_modules 表
#[cfg(feature = "export-modules")]
ngx::ngx_modules!(ngx_http_ipass_module);
#[used]
#[allow(non_upper_case_globals)]
pub static mut ngx_http_ipass_module: ngx_module_t = ngx_module_t {
ctx: &raw const NGX_HTTP_IPASS_MODULE_CTX as _,
commands: unsafe { &raw mut NGX_HTTP_IPASS_COMMANDS[0] },
type_: NGX_HTTP_MODULE as _,
init_process: Some(init_process),
..ngx_module_t::default()
};
/// 每个 worker 启动后执行一次。管理员播种是**幂等**的:
/// 文件里已有任何账号就直接跳过,所以多 worker 同时跑不会重复创建。
unsafe extern "C" fn init_process(_cycle: *mut ngx_cycle_t) -> ngx_int_t {
match users::seed_admin() {
Ok(true) => util::log_warn(
"[ipass] 已创建初始管理员 admin,请首次登录后立即修改密码",
),
Ok(false) => {}
Err(e) => util::log_err(&format!("[ipass] 初始化管理员失败: {e}")),
}
Status::NGX_OK.into()
}
// ===========================================================================
// 指令处理
// ===========================================================================
/// 读第 2 个参数并转成 bool(on/off/1/0/yes/no)。
unsafe fn arg_flag(cf: *mut ngx_conf_t, idx: usize) -> Option<bool> {
let cf_ref = unsafe { cf.as_mut() }?;
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
let raw = args.get(idx)?.as_bytes();
let s = core::str::from_utf8(raw).ok()?;
Some(matches!(s.to_ascii_lowercase().as_str(), "on" | "1" | "true" | "yes"))
}
extern "C" fn set_flag_proxy(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
conf: *mut c_void,
) -> *mut c_char {
let Some(flag) = (unsafe { arg_flag(cf, 1) }) else {
return NGX_CONF_ERROR;
};
// SAFETY: nginx 保证 conf 指向本模块的 loc conf 结构
unsafe { (*(conf as *mut ModuleConfig)).proxy = flag };
NGX_CONF_OK
}
extern "C" fn set_flag_api(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
conf: *mut c_void,
) -> *mut c_char {
let Some(flag) = (unsafe { arg_flag(cf, 1) }) else {
return NGX_CONF_ERROR;
};
// SAFETY: 同上
unsafe { (*(conf as *mut ModuleConfig)).api = flag };
NGX_CONF_OK
}
extern "C" fn set_flag_llm(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
conf: *mut c_void,
) -> *mut c_char {
let Some(flag) = (unsafe { arg_flag(cf, 1) }) else {
return NGX_CONF_ERROR;
};
// SAFETY: 同上
unsafe { (*(conf as *mut ModuleConfig)).llm = flag };
NGX_CONF_OK
}
extern "C" fn set_state_zone(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
_conf: *mut c_void,
) -> *mut c_char {
// SAFETY: 配置回调必然拿到有效的 cf
let cf_ref = unsafe { cf.as_mut().unwrap() };
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
let mut name: ngx_str_t = args[1];
let size = unsafe { ngx_parse_size(&raw mut args[2]) };
if size == -1 {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_state: 共享内存大小非法");
return NGX_CONF_ERROR;
}
let zone = unsafe {
ngx_shared_memory_add(
cf,
&raw mut name,
size as usize,
(&raw mut ngx_http_ipass_module).cast(),
)
};
if zone.is_null() {
return NGX_CONF_ERROR;
}
unsafe {
(*zone).init = Some(state_zone_init);
}
state::set_zone(zone);
NGX_CONF_OK
}
/// 共享内存初始化:由 nginx 在 **fork 之前**调用一次。
///
/// 在这里装载三张表,所有 worker 直接共享结果——比放在
/// `init_process`(每个 worker 各跑一遍)省掉 N-1 次文件读与 JSON 解析。
extern "C" fn state_zone_init(zone: *mut ngx_shm_zone_t, _data: *mut c_void) -> ngx_int_t {
let status = state::init_zone(zone);
if status != Status::NGX_OK {
return status.into();
}
let loaded = domains::reload_shm();
util::log_notice(&format!("[ipass] 共享内存已装载 {loaded} 条转发映射"));
// 账号 Key 与 LLM 上游必须一起进内存:LLM 热路径未命中即 401 / 404,
// 没有任何回源兜底(同 domains 的写穿语义)。
let keys = users::reload_shm();
let ups = upstreams::reload_shm();
util::log_notice(&format!(
"[ipass] 已装载 {keys} 个账号 Key、{ups} 个 LLM 上游"
));
Status::NGX_OK.into()
}
extern "C" fn set_data_dir(
cf: *mut ngx_conf_t,
_cmd: *mut ngx_command_t,
_conf: *mut c_void,
) -> *mut c_char {
// SAFETY: 配置回调必然拿到有效的 cf
let cf_ref = unsafe { cf.as_mut().unwrap() };
let args: &mut [ngx_str_t] = unsafe { (*cf_ref.args).as_slice_mut() };
match core::str::from_utf8(args[1].as_bytes()) {
Ok(dir) => {
store::set_data_dir(dir);
NGX_CONF_OK
}
Err(_) => {
ngx_conf_log_error!(NGX_LOG_EMERG, cf_ref, "ipass_data_dir: 路径不是合法 UTF-8");
NGX_CONF_ERROR
}
}
}
/// 供测试与诊断使用:`NgxStr` 类型在模块里被多处引用,确保编译期链接到正确的符号
#[allow(dead_code)]
fn _type_witness(_: &NgxStr, _: &NgxString<SlabPool>) {}