Skip to main content

rws_http/entry_point/config_file/
mod.rs

1use std::collections::HashMap;
2use std::env;
3use std::io::{BufRead, Cursor};
4use crate::entry_point::command_line_args::CommandLineArgument;
5use file_ext::FileExt;
6
7#[doc(hidden)]
8pub mod toml_str;
9use toml_str::{unquote, Quotes};
10
11#[cfg(test)]
12mod tests;
13
14/// Settings that have an `RWS_CONFIG_*` variable but no command-line flag.
15/// In `rws.config.toml` they're written like any other key — the variable
16/// name is the table path plus key, upper-cased: `[rate_limit] max_requests`
17/// → `RWS_CONFIG_RATE_LIMIT_MAX_REQUESTS`. Settings that do have a flag are
18/// taken from `CommandLineArgument::get_command_line_arg_list()` instead.
19/// `tests.rs` checks this list against every `RWS_CONFIG_*` name in `src/`.
20pub const SETTINGS_WITHOUT_FLAG: &[&str] = &[
21    "RWS_CONFIG_CACHE_STATUS",
22    "RWS_CONFIG_TLS_INTERNAL_DIR",
23    "RWS_CONFIG_TLS_INTERNAL_NAMES",
24    "RWS_CONFIG_ERROR_FORMAT",
25    "RWS_CONFIG_MAINTENANCE_MESSAGE",
26    "RWS_CONFIG_MAINTENANCE_RETRY_AFTER_SECS",
27    "RWS_CONFIG_TLS_CLIENT_CRL_FILE",
28    "RWS_CONFIG_TLS_CLIENT_CRL_STRICT",
29    "RWS_CONFIG_FORWARDED_HEADER",
30    "RWS_CONFIG_TRUSTED_PROXIES",
31    "RWS_CONFIG_METRICS_ALLOW",
32    "RWS_CONFIG_SHUTDOWN_DELAY_SECS",
33    "RWS_CONFIG_SHUTDOWN_TIMEOUT_SECS",
34    "RWS_CONFIG_CLIENT_IP",
35    "RWS_CONFIG_PROXY_NAME",
36    "RWS_CONFIG_PROXY_STATUS",
37    "RWS_CONFIG_PROXY_STATUS_NEXT_HOP",
38    "RWS_CONFIG_ACME_ACCOUNT_KEY_PATH",
39    "RWS_CONFIG_ADMIN_ALLOWED_ORIGINS",
40    "RWS_CONFIG_ADMIN_USERS",
41    "RWS_CONFIG_ADMIN_COUNT_OWN_REQUESTS",
42    "RWS_CONFIG_CLUSTER_NODE",
43    "RWS_CONFIG_FLEET_SOURCE",
44    "RWS_CONFIG_FLEET_INTERVAL_SECS",
45    "RWS_CONFIG_FLEET_PUBLIC_KEY",
46    "RWS_CONFIG_FLEET_INSECURE",
47    "RWS_CONFIG_FLEET_REPORT_URL",
48    "RWS_CONFIG_FLEET_S3_ENDPOINT",
49    "RWS_CONFIG_CLUSTER_REDIS",
50    "RWS_CONFIG_CLUSTER_REDIS_PASSWORD",
51    "RWS_CONFIG_CLUSTER_PREFIX",
52    "RWS_CONFIG_ADMIN_AUDIT_LOG",
53    "RWS_CONFIG_ADMIN_OIDC_ISSUER",
54    "RWS_CONFIG_ADMIN_OIDC_PROVIDER",
55    "RWS_CONFIG_ADMIN_OIDC_TENANT",
56    "RWS_CONFIG_ADMIN_OIDC_CLIENT_ID",
57    "RWS_CONFIG_ADMIN_OIDC_CLIENT_SECRET_ENV",
58    "RWS_CONFIG_ADMIN_OIDC_COOKIE_SECRET_ENV",
59    "RWS_CONFIG_ADMIN_OIDC_ROLES",
60    "RWS_CONFIG_ADMIN_OIDC_ROLE_CLAIM",
61    "RWS_CONFIG_ADMIN_LISTEN",
62    "RWS_CONFIG_ADMIN_TOKEN_ENV",
63    "RWS_CONFIG_ACME_RENEW_BEFORE_DAYS",
64    "RWS_CONFIG_ACME_RENEW_CHECK_INTERVAL_SECS",
65    "RWS_CONFIG_CIRCUIT_BREAKER_FAILURE_THRESHOLD",
66    "RWS_CONFIG_CIRCUIT_BREAKER_MAX_HALF_OPEN_PROBES",
67    "RWS_CONFIG_CIRCUIT_BREAKER_RECOVERY_SECS",
68    "RWS_CONFIG_CLIENT_HINTS",
69    "RWS_CONFIG_CSP",
70    "RWS_CONFIG_ACME_DNS_TSIG_SECRET",
71    "RWS_CONFIG_ACME_REDIS_PASSWORD",
72    "RWS_CONFIG_ACME_DNS_API_TOKEN",
73    "RWS_CONFIG_ACCESS_LOG",
74    "RWS_CONFIG_ACCESS_LOG_KEEP",
75    "RWS_CONFIG_ACCESS_LOG_MAX_SIZE",
76    "RWS_CONFIG_ACCESS_LOG_ANONYMIZE_IP",
77    "RWS_CONFIG_ACCESS_LOG_IP_HASH_SECRET",
78    "RWS_CONFIG_ACCESS_LOG_SYSLOG",
79    "RWS_CONFIG_ACCESS_LOG_SYSLOG_FACILITY",
80    "RWS_CONFIG_LOG_REDACT_HEADERS",
81    "RWS_CONFIG_LOG_REDACT_QUERY",
82    "RWS_CONFIG_GATEWAY_API_CONTROLLER_NAME",
83    "RWS_CONFIG_GATEWAY_API_ENABLED",
84    "RWS_CONFIG_GATEWAY_API_EXPERIMENTAL",
85    "RWS_CONFIG_GATEWAY_API_GATEWAY",
86    "RWS_CONFIG_GATEWAY_API_IMAGE",
87    "RWS_CONFIG_GATEWAY_API_LEASE_NAMESPACE",
88    "RWS_CONFIG_GATEWAY_API_MESH",
89    "RWS_CONFIG_GATEWAY_API_MESH_CONFIG_URL",
90    "RWS_CONFIG_GATEWAY_API_MESH_INIT_IMAGE",
91    "RWS_CONFIG_GATEWAY_API_MESH_PORT",
92    "RWS_CONFIG_GATEWAY_API_MESH_SIDECAR_IMAGE",
93    "RWS_CONFIG_GATEWAY_API_MESH_WEBHOOK_CERT_FILE",
94    "RWS_CONFIG_GATEWAY_API_MESH_WEBHOOK_KEY_FILE",
95    "RWS_CONFIG_GATEWAY_API_MESH_WEBHOOK_PORT",
96    "RWS_CONFIG_GATEWAY_API_MODE",
97    "RWS_CONFIG_GATEWAY_API_POD_SELECTOR",
98    "RWS_CONFIG_GATEWAY_API_PORT_RANGE",
99    "RWS_CONFIG_GATEWAY_API_SERVICE_ACCOUNT",
100    "RWS_CONFIG_GATEWAY_API_SERVICE_TYPE",
101    "RWS_CONFIG_COMPRESSION_DICTIONARIES",
102    "RWS_CONFIG_EARLY_HINTS_HTTP1",
103    "RWS_CONFIG_LOG_FORMAT",
104    "RWS_CONFIG_MAX_BODY_SIZE_IN_BYTES",
105    "RWS_CONFIG_MIN_FREE_DISK",
106    "RWS_CONFIG_NANOS_HEADERS",
107    "RWS_CONFIG_OPEN_FILE_CACHE_SECS",
108    "RWS_CONFIG_OPEN_FILE_CACHE_STRICT",
109    "RWS_CONFIG_PROXY_PROTOCOL",
110    "RWS_CONFIG_RATE_LIMIT_MAX_REQUESTS",
111    "RWS_CONFIG_RATE_LIMIT_WINDOW_SECS",
112    "RWS_CONFIG_RUNTIME",
113    "RWS_CONFIG_SECURITY_HEADERS",
114    "RWS_CONFIG_SERVE_DOTFILES",
115    "RWS_CONFIG_SPA_FALLBACK",
116    "RWS_CONFIG_SPA_FALLBACK_EXCLUDE_PREFIXES",
117    "RWS_CONFIG_SPA_FALLBACK_ROUTES",
118    "RWS_CONFIG_STATIC_CACHE_CONTROL",
119    "RWS_CONFIG_DIRECTORY_LISTING",
120    "RWS_CONFIG_TEMPLATE_DIR",
121    "RWS_CONFIG_TLS_CLIENT_CA_FILE",
122    "RWS_CONFIG_WATCH",
123    "RWS_CONFIG_TRAFFIC_DATABASE_URL_ENV",
124    "RWS_CONFIG_TRAFFIC_ENABLED",
125    "RWS_CONFIG_TRAFFIC_EXCLUDE",
126    "RWS_CONFIG_TRAFFIC_GEO_DB",
127    "RWS_CONFIG_TRAFFIC_GOALS",
128    "RWS_CONFIG_TRAFFIC_HOSTING_NETWORKS",
129    "RWS_CONFIG_TRAFFIC_APPS",
130    "RWS_CONFIG_TRAFFIC_OWNER_NETWORKS",
131    "RWS_CONFIG_TRAFFIC_PROBE_ADDRESSES",
132    "RWS_CONFIG_TRAFFIC_HIDE_HOSTS",
133    "RWS_CONFIG_TRAFFIC_IGNORE_REFERRERS",
134    "RWS_CONFIG_TRAFFIC_PERSIST",
135    "RWS_CONFIG_TRAFFIC_RETENTION_DAYS",
136    "RWS_CONFIG_TRAFFIC_SCRIPT",
137];
138
139/// Tables (and their sub-tables) read by `proxy_config`'s own parser, not
140/// mapped to `RWS_CONFIG_*` variables.
141const PROXY_TABLES: &[&str] = &["route", "upstream", "tcp_proxy", "udp_proxy", "ws_proxy", "middleware", "authz"];
142
143/// `[[virtual_host]]` fields, set as `RWS_CONFIG_VIRTUAL_HOST_<n>_<FIELD>`.
144const VIRTUAL_HOST_FIELDS: &[&str] = &["DOMAIN", "CERT_FILE", "KEY_FILE"];
145
146/// The settings of a `rws.config.toml` document, resolved to the
147/// `RWS_CONFIG_*` variables they set — without touching the environment.
148#[derive(Debug, Default, PartialEq)]
149pub struct ConfigSettings {
150    /// `(RWS_CONFIG_* name, value)` in file order.
151    pub settings: Vec<(String, String)>,
152    /// Keys no setting answers to, as `key` or `[table] key`.
153    pub unknown: Vec<String>,
154}
155
156/// Resolve every setting in a `rws.config.toml` document. `prefix` is the
157/// table the document starts in (normally empty).
158///
159/// Top-level keys and keys in plain `[tables]` map to `RWS_CONFIG_<TABLE>_<KEY>`
160/// (`[cors] allow_all` → `RWS_CONFIG_CORS_ALLOW_ALL`); each `[[virtual_host]]`
161/// block maps to `RWS_CONFIG_VIRTUAL_HOST_<n>_*`. Strings keep their exact
162/// contents (spaces, quotes inside them); arrays become comma-separated lists.
163/// Proxy tables (`[[route]]`, `[[upstream]]`, …) are left to `proxy_config`.
164pub fn collect_settings(
165    cursor: Cursor<&[u8]>,
166    prefix: String) -> Result<ConfigSettings, String> {
167
168    let mut table = prefix;
169    // Index of the current [[array-table]] entry, per array-table name.
170    let mut array_table_counters: HashMap<String, usize> = HashMap::new();
171    let mut array_index: Option<usize> = None;
172    let mut resolved = ConfigSettings::default();
173    let flags = CommandLineArgument::get_command_line_arg_list();
174
175    for line in cursor.lines() {
176        let line = line.map_err(|e| e.to_string())?;
177        let line = strip_comment(&line).trim().to_string();
178        if line.is_empty() {
179            continue;
180        }
181
182        if let Some(name) = line.strip_prefix("[[").and_then(|l| l.strip_suffix("]]")) {
183            let name = name.trim().to_string();
184            let count = array_table_counters.entry(name.clone()).or_insert(0);
185            array_index = Some(*count);
186            *count += 1;
187            table = name;
188            continue;
189        }
190        if let Some(name) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {
191            table = name.trim().to_string();
192            array_index = None;
193            continue;
194        }
195
196        let Some((raw_key, raw_value)) = line.split_once('=') else { continue };
197        let key = raw_key.trim();
198
199        let root = table.split('.').next().unwrap_or("");
200        if PROXY_TABLES.contains(&root) {
201            continue;
202        }
203
204        // An inline table, `rate_limit = { max_requests = 5 }`, is the
205        // sub-table `[rate_limit]` (or `[<table>.rate_limit]`), as in TOML
206        // and as in the proxy sections.
207        if let Some(inner) = raw_value.trim().strip_prefix('{').and_then(|v| v.strip_suffix('}')) {
208            let sub_table = if table.is_empty() { key.to_string() } else { format!("{}.{}", table, key) };
209            for entry in split_top_level(inner) {
210                if let Some((inner_key, inner_value)) = entry.split_once('=') {
211                    resolve_setting(&sub_table, array_index, inner_key.trim(), parse_value(inner_value), &flags, &mut resolved);
212                } else if !entry.trim().is_empty() {
213                    resolved.unknown.push(qualified_key(&sub_table, entry.trim()));
214                }
215            }
216            continue;
217        }
218
219        resolve_setting(&table, array_index, key, parse_value(raw_value), &flags, &mut resolved);
220    }
221
222    Ok(resolved)
223}
224
225/// Map one `key = value` in `table` to its `RWS_CONFIG_*` setting, or record
226/// it as unknown.
227fn resolve_setting(
228    table: &str,
229    array_index: Option<usize>,
230    key: &str,
231    value: String,
232    flags: &[CommandLineArgument],
233    resolved: &mut ConfigSettings,
234) {
235    if table == "virtual_host" {
236        let field = key.to_ascii_uppercase();
237        if VIRTUAL_HOST_FIELDS.contains(&field.as_str()) {
238            let name = format!("RWS_CONFIG_VIRTUAL_HOST_{}_{}", array_index.unwrap_or(0), field);
239            resolved.settings.push((name, value));
240        } else {
241            resolved.unknown.push(qualified_key(table, key));
242        }
243        return;
244    }
245
246    let path = if table.is_empty() { key.to_string() } else { format!("{}_{}", table.replace('.', "_"), key) };
247    let long_form = path.replace('_', "-");
248    if let Some(flag) = flags.iter().find(|f| f.long_form == long_form) {
249        resolved.settings.push((flag.environment_variable.clone(), value));
250        return;
251    }
252    let name = format!("RWS_CONFIG_{}", path.to_ascii_uppercase());
253    if SETTINGS_WITHOUT_FLAG.contains(&name.as_str()) {
254        resolved.settings.push((name, value));
255    } else {
256        resolved.unknown.push(qualified_key(table, key));
257    }
258}
259
260/// Split an inline table's body on commas outside quotes and `[...]`.
261fn split_top_level(inner: &str) -> Vec<&str> {
262    let mut items = vec![];
263    let mut quote: Option<char> = None;
264    let mut depth = 0usize;
265    let mut start = 0;
266    for (i, c) in inner.char_indices() {
267        match (quote, c) {
268            (None, '"') | (None, '\'') => quote = Some(c),
269            (Some(q), c) if c == q => quote = None,
270            (None, '[') => depth += 1,
271            (None, ']') => depth = depth.saturating_sub(1),
272            (None, ',') if depth == 0 => {
273                items.push(&inner[start..i]);
274                start = i + 1;
275            }
276            _ => {}
277        }
278    }
279    items.push(&inner[start..]);
280    items
281}
282
283/// Apply every setting in a `rws.config.toml` document to the process
284/// environment (see [`collect_settings`]). Unknown keys are reported on
285/// stderr instead of being ignored silently.
286pub fn read_config_file(
287    cursor: Cursor<&[u8]>,
288    prefix: String) -> Result<bool, String> {
289    let resolved = collect_settings(cursor, prefix)?;
290    for (name, value) in &resolved.settings {
291        set_setting(name, value);
292    }
293    for key in &resolved.unknown {
294        eprintln!("Warning: unknown setting '{}' in rws.config.toml — ignored{}", key, crate::entry_point::config_file::suggestion(key).map(|s| format!(" (did you mean '{s}'?)")).unwrap_or_default());
295    }
296    Ok(true)
297}
298
299/// The known setting closest to an unknown `key` (`[admn] listen` →
300/// `[admin] listen`), written the way the unknown one was.
301pub fn suggestion(key: &str) -> Option<String> {
302    let (table, name) = match key.strip_prefix('[').and_then(|k| k.split_once("] ")) {
303        Some((t, n)) => (t.to_string(), n.to_string()),
304        None => (String::new(), key.to_string()),
305    };
306    let path = if table.is_empty() { name.clone() } else { format!("{}_{}", table.replace('.', "_"), name) };
307    let path = path.to_ascii_lowercase();
308    let mut known: Vec<String> = CommandLineArgument::get_command_line_arg_list().iter().map(|f| f.long_form.replace('-', "_")).collect();
309    known.extend(SETTINGS_WITHOUT_FLAG.iter().map(|n| n.trim_start_matches("RWS_CONFIG_").to_ascii_lowercase()));
310    let limit = if path.len() < 4 { 1 } else { 2 };
311    let best = known
312        .iter()
313        .map(|k| (crate::entry_point::edit_distance(&path, k), k))
314        .filter(|(d, _)| *d <= limit && *d > 0)
315        .min_by_key(|(d, _)| *d)?
316        .1
317        .clone();
318    // Same shape as the unknown key: `[table] key` when the key matches.
319    if let Some(t) = best.strip_suffix(&format!("_{}", name.to_ascii_lowercase())) {
320        return Some(format!("[{t}] {name}"));
321    }
322    if !table.is_empty() {
323        for (i, _) in best.match_indices('_') {
324            let (t, k) = (&best[..i], &best[i + 1..]);
325            if crate::entry_point::edit_distance(t, &table) <= 2 {
326                return Some(format!("[{t}] {k}"));
327            }
328        }
329    }
330    Some(best)
331}
332
333fn set_setting(name: &str, value: &str) {
334    if value.contains('\0') {
335        // env::set_var panics on NUL — a stray byte in the file must not crash startup.
336        eprintln!("    Warning: value for {} contains a NUL byte — ignored", name);
337        return;
338    }
339    env::set_var(name, value);
340    crate::server_config::invalidate();
341    startup_note!("    Set env variable '{}' to value '{}'", name, crate::entry_point::shown(name, value));
342}
343
344fn qualified_key(table: &str, key: &str) -> String {
345    if table.is_empty() { key.to_string() } else { format!("[{}] {}", table, key) }
346}
347
348/// Drop a trailing `# comment`, ignoring `#` inside quoted strings.
349fn strip_comment(line: &str) -> &str {
350    let mut quotes = Quotes::default();
351    for (i, c) in line.char_indices() {
352        if !quotes.step(c) && c == '#' {
353            return &line[..i];
354        }
355    }
356    line
357}
358
359/// A TOML value as a plain string: quoted strings lose their quotes (basic
360/// strings also their escapes, see [`toml_str::unquote`]), arrays become
361/// `a,b,c`, anything else (numbers, booleans) is trimmed.
362fn parse_value(raw: &str) -> String {
363    let raw = raw.trim();
364    if let Some(inner) = raw.strip_prefix('[').and_then(|r| r.strip_suffix(']')) {
365        return split_array(inner)
366            .iter()
367            .map(|item| unquote(item.trim()))
368            .filter(|item| !item.is_empty())
369            .collect::<Vec<_>>()
370            .join(",");
371    }
372    unquote(raw)
373}
374
375/// Split array items on commas outside quotes.
376fn split_array(inner: &str) -> Vec<&str> {
377    let mut items = vec![];
378    let mut quotes = Quotes::default();
379    let mut start = 0;
380    for (i, c) in inner.char_indices() {
381        if !quotes.step(c) && c == ',' {
382            items.push(&inner[start..i]);
383            start = i + 1;
384        }
385    }
386    items.push(&inner[start..]);
387    items
388}
389
390/// Load `rws.config.toml` into the environment: `filepath` (relative to the
391/// working directory) when given, else the file named by `RWS_CONFIG_FILE`
392/// (absolute, or relative to the working directory) — the same variable
393/// `proxy_config` reads routes from — else `rws.config.toml` in the working
394/// directory.
395pub fn override_environment_variables_from_config(filepath: Option<&str>) {
396    startup_note!("\n  Start of Config Section");
397
398    let from_env = env::var("RWS_CONFIG_FILE").ok().filter(|p| !p.trim().is_empty());
399    let resolved = match (filepath, from_env) {
400        (Some(path), _) => FileExt::get_static_filepath(path),
401        (None, Some(path)) => Ok(path),
402        (None, None) => FileExt::get_static_filepath("/rws.config.toml"),
403    };
404    let path = match resolved {
405        Ok(path) => path,
406        Err(e) => {
407            eprintln!("{}", e);
408            startup_note!("  End of Config Section");
409            return;
410        }
411    };
412
413    let named = filepath.is_some() || env::var("RWS_CONFIG_FILE").is_ok_and(|p| !p.trim().is_empty());
414    let mut source = None;
415    match std::fs::read_to_string(&path) {
416        Ok(content) => {
417            if let Err(e) = read_config_file(Cursor::new(content.as_bytes()), String::new()) {
418                eprintln!("    Unable to parse {}: {}", path, e);
419            }
420            source = Some(path.clone());
421        }
422        // No ./rws.config.toml is the normal config-less start, not an
423        // error; a file named by RWS_CONFIG_FILE that can't be read is.
424        Err(e) if e.kind() == std::io::ErrorKind::NotFound && !named => {
425            startup_note!("    No {} — defaults, environment and flags only", path);
426        }
427        Err(e) => eprintln!("Unable to read {}: {}", path, e),
428    }
429    if let Ok(mut slot) = crate::entry_point::CONFIG_SOURCE.lock() {
430        *slot = source;
431    }
432
433    startup_note!("  End of Config Section");
434}