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
14pub 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
139const PROXY_TABLES: &[&str] = &["route", "upstream", "tcp_proxy", "udp_proxy", "ws_proxy", "middleware", "authz"];
142
143const VIRTUAL_HOST_FIELDS: &[&str] = &["DOMAIN", "CERT_FILE", "KEY_FILE"];
145
146#[derive(Debug, Default, PartialEq)]
149pub struct ConfigSettings {
150 pub settings: Vec<(String, String)>,
152 pub unknown: Vec<String>,
154}
155
156pub fn collect_settings(
165 cursor: Cursor<&[u8]>,
166 prefix: String) -> Result<ConfigSettings, String> {
167
168 let mut table = prefix;
169 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 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
225fn 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
260fn 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
283pub 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
299pub 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 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 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
348fn 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
359fn 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
375fn 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
390pub 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 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}