//! iPass 山海关(ipass-gateway)—— nginx + Rust 动态模块(v2) //! //! 尚数网 统一网关(动态域名 / LLM API 路由及未来各类统一出口能力)。 //! 本模块承担原 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//*` | 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, _>` 一种安全形态; //! `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 stats; mod store; mod upstreams; mod util; mod users; use core::ffi::{c_char, c_void}; use core::ptr; use core::sync::atomic::{AtomicIsize, 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_indexed_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 { 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> { // 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 无效或已失效", ); }; // 「列出可用模型」是网关自己的元信息接口(OpenAI 兼容形状), // 在查上游之前就地应答——否则 `/v1/models` 会被当成 slot=v1 → 404。 if llm::is_models_probe(r) { return llm::respond_models(r, &allowed); } 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; } // 用量统计:走到这里说明请求**真的会被转发**,才计入。 // 被拒的请求(401/403/404/429)不进统计——那是给人看的数字, // 把拒绝也算进"用量"只会误导(与配额计数 st: 的语义刻意不同)。 stats::record(&username, &slot, util::now()); Status::NGX_DECLINED } } /// `$upstream_status` 的变量索引,postconfiguration 时解析一次(log 阶段复用)。 static UPSTREAM_STATUS_IDX: AtomicIsize = AtomicIsize::new(-1); /// LLM 上游健康标记(log 阶段):把上游**真实**状态码写进 `uh:` 缓存。 /// /// 为什么在 log 阶段:转发决策在 access、响应在 proxy 模块手里,只有 log /// 阶段能同时拿到「slot 是谁」和「上游实际回了什么」。这相当于让**真实流量 /// 自己当探针**——不需要额外的常驻探测进程(项目红线),健康状态也最真实。 /// 管理台「测试」按钮的探测请求走同一条 `proxy_pass` 链路,天然共用本逻辑。 /// /// 写下的缓存**只用于展示**(列表标红 / 模型发现附状态),转发路径不读它, /// 误标不影响任何请求的结果。 /// /// ⚠️ 状态码从 `$upstream_status` 变量读,**不能读 `r->upstream`**—— /// `ngx_http_upstream_finalize_request` 在日志阶段之前就把 `r->upstream` /// 置空了(实测踩过:代码编译通过、跑起来状态永远是 unknown)。 /// access log 模块同款手法:变量在 finalize 时快照,log 阶段仍有效。 struct LlmHealthHandler; impl HttpRequestHandler for LlmHealthHandler { const PHASE: HttpPhase = HttpPhase::Log; type Output = Status; fn handler(request: &mut ngx::http::Request) -> Self::Output { let r: *mut ngx_http_request_t = request.as_mut() as *mut ngx_http_request_t; // 两类请求要标记: // ① LLM server 的真实转发流量(location_conf.llm == true); // ② 管理台探测流量——内部重定向到管理 server 的 /_upstream_test location, // 那里**没有** ipass_llm 指令(有就会重跑 access 鉴权,探测请求只有 // 登录会话没有 API Key),所以只能按 URI 前缀认。 let uri = crate::http::uri(r); let is_llm = Module::location_conf(request).map(|c| c.llm).unwrap_or(false); let is_probe = uri.starts_with("/_upstream_test"); if !is_llm && !is_probe { return Status::NGX_DECLINED; } // SAFETY: r 有效;索引在 postconfiguration 已解析(见 postconfiguration) let code = unsafe { let idx = UPSTREAM_STATUS_IDX.load(Ordering::Relaxed); if idx < 0 { 0 } else { let v = ngx_http_get_indexed_variable(r, idx as ngx_uint_t); if (*v).not_found() != 0 || (*v).data.is_null() { 0 } else { let s = core::str::from_utf8(core::slice::from_raw_parts( (*v).data, (*v).len() as usize, )) .unwrap_or(""); // 内部重定向会有多段(如 "502, 200"),取**最后一段** = 最近一次上游尝试 s.rsplit(',').next().unwrap_or("").trim().parse().unwrap_or(0) } } }; // 没有 upstream(本地应答如 /v1/models)或没拿到状态码(客户端中途 // 断连等)→ 无从判断,不写缓存,留给下一次真实转发 if code == 0 { return Status::NGX_DECLINED; } if let Some(slot) = llm::slot_of(r) { // 上游回了头 = 它活着:2xx~4xx 都算正常(4xx 是它对我们请求的意见, // 不是机器死了);5xx / 连接失败(502) / 等头超时(504) 才算失效 upstreams::mark_health(&slot, (200..500).contains(&code), code); } 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 代理(`//...` → 上游) 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::(cf).is_err() { return Status::NGX_ERROR.into(); } if ngx::http::add_phase_handler::(cf).is_err() { return Status::NGX_ERROR.into(); } if ngx::http::add_phase_handler::(cf).is_err() { return Status::NGX_ERROR.into(); } if ngx::http::add_phase_handler::(cf).is_err() { return Status::NGX_ERROR.into(); } // 预取 `$upstream_status` 索引(upstream 模块 preconfiguration 已注册该内建变量) let mut name = ngx_str_t { len: "upstream_status".len() as usize, data: b"upstream_status\0".as_ptr() as *mut u8, }; let idx = ngx_http_get_variable_index(cf, &mut name); if idx == -1 { return Status::NGX_ERROR.into(); } UPSTREAM_STATUS_IDX.store(idx as isize, Ordering::Relaxed); 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 { 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) {}