Skip to main content

tuwunel_router/
serve.rs

1mod plain;
2#[cfg(test)]
3mod tests;
4#[cfg(feature = "direct_tls")]
5mod tls;
6mod unix;
7
8#[cfg(unix)]
9use std::{borrow::Cow, os::unix::net::UnixListener};
10use std::{
11	iter::once,
12	net::{Ipv4Addr, SocketAddr, TcpListener},
13	path::Path,
14	sync::{Arc, atomic::Ordering},
15};
16
17use tokio::task::JoinSet;
18use tuwunel_core::{Err, Result, debug_info, error, info};
19#[cfg(unix)]
20use tuwunel_core::{itertools::Itertools, utils::sys::is_ipv6_only};
21use tuwunel_service::Services;
22
23use super::layers;
24use crate::handle::ServerHandle;
25
26/// Serve clients
27pub(super) async fn serve(services: Arc<Services>, handle: ServerHandle) -> Result {
28	let server = &services.server;
29	let config = &server.config;
30
31	#[cfg(not(feature = "oidc"))]
32	if services.oauth.get_server().is_ok() {
33		return if config.authentication.oidc.native_auth {
34			Err!(Config(
35				"authentication.oidc.native_auth",
36				"tuwunel was not built with OIDC support (\"oidc\")"
37			))
38		} else {
39			Err!(Config(
40				"identity_provider",
41				"tuwunel was not built with OIDC support (\"oidc\")"
42			))
43		};
44	}
45
46	#[cfg(not(feature = "mas"))]
47	if config
48		.authentication
49		.mas_secret
50		.as_deref()
51		.is_some_and(|secret| !secret.is_empty())
52	{
53		return Err!(Config(
54			"authentication.mas_secret",
55			"tuwunel was not built with MAS provisioning support (\"mas\")"
56		));
57	}
58
59	let (app, _guard) = layers::build(&services)?;
60
61	let mut join_set = JoinSet::new();
62
63	let socket_path = &config.http.listen.unix_socket_path;
64
65	#[cfg(unix)]
66	let (passed_tcp_listeners, passed_unix_listeners) = systemd_listeners()?;
67	#[cfg(not(unix))]
68	let passed_tcp_listeners: Vec<TcpListener> = Vec::new();
69
70	let addrs = config.get_bind_addrs();
71
72	#[cfg(unix)]
73	let mut listening = passed_addrs(&passed_tcp_listeners)?;
74	#[cfg(not(unix))]
75	let mut listening: Vec<SocketAddr> = Vec::new();
76
77	#[cfg(unix)]
78	let socket_path = unpassed_path(socket_path.as_deref(), &passed_unix_listeners)?;
79	#[cfg(not(unix))]
80	let socket_path = socket_path.as_deref();
81
82	let defaulted = config.is_address_defaulted();
83	let tcp_listeners = bind_addrs(&addrs, &mut listening, defaulted)?;
84
85	#[cfg(unix)]
86	let log_addrs = make_log_addrs(
87		&tcp_listeners,
88		socket_path,
89		&passed_tcp_listeners,
90		&passed_unix_listeners,
91	)?;
92	#[cfg(not(unix))]
93	let log_addrs = make_log_addrs(&tcp_listeners, socket_path, &passed_tcp_listeners)?;
94
95	let mut futures = vec![];
96
97	#[cfg(unix)]
98	{
99		let socket_perms = config.get_unix_socket_perms()?;
100
101		let unix_futures = unix::serve(
102			&app,
103			&handle.handle_unix,
104			passed_unix_listeners.into_iter(),
105			socket_path,
106			socket_perms,
107		)
108		.await?;
109
110		futures.extend(unix_futures);
111	};
112
113	#[cfg_attr(
114		not(feature = "direct_tls"),
115		expect(clippy::redundant_else, unused_variables)
116	)]
117	if let Some((cert, key)) = config.tls.get_tls_cert_key() {
118		#[cfg(feature = "direct_tls")]
119		{
120			services.globals.init_rustls_provider()?;
121
122			let listeners = tcp_listeners
123				.into_iter()
124				.chain(passed_tcp_listeners);
125
126			let tls_futures = tls::serve(
127				&app,
128				&handle.handle_ip,
129				cert,
130				key,
131				config.tls.dual_protocol,
132				listeners,
133			)
134			.await?;
135
136			futures.extend(tls_futures);
137		}
138
139		#[cfg(not(feature = "direct_tls"))]
140		return tuwunel_core::Err!(Config(
141			"tls",
142			"tuwunel was not built with direct TLS support (\"direct_tls\")"
143		));
144	} else {
145		let listeners = tcp_listeners
146			.into_iter()
147			.chain(passed_tcp_listeners);
148
149		let plain_futures = plain::serve(&app, &handle.handle_ip, listeners)?;
150
151		futures.extend(plain_futures);
152	}
153
154	for future in futures {
155		join_set.spawn_on(future, server.runtime());
156	}
157
158	if join_set.is_empty() {
159		return Err!("at least one listener should be installed");
160	}
161
162	info!("Listening on {log_addrs:?}");
163
164	join_set
165		.join_all()
166		.await
167		.into_iter()
168		.filter_map(Result::err)
169		.for_each(|e| error!("Listener stopped: {e}"));
170
171	let handle_active = server
172		.metrics
173		.requests_handle_active
174		.load(Ordering::Acquire);
175
176	debug_info!(
177		handle_finished = server
178			.metrics
179			.requests_handle_finished
180			.load(Ordering::Acquire),
181		panics = server
182			.metrics
183			.requests_panic
184			.load(Ordering::Acquire),
185		handle_active,
186		"Stopped listening on {log_addrs:?}",
187	);
188
189	debug_assert_eq!(0, handle_active, "active request handles still pending");
190
191	Ok(())
192}
193
194/// Addresses the service manager already listens on for us.
195#[cfg(unix)]
196fn passed_addrs(listeners: &[TcpListener]) -> Result<Vec<SocketAddr>> {
197	listeners
198		.iter()
199		.map(listening_addrs)
200		.flatten_ok()
201		.try_collect()
202}
203
204/// Addresses a listener answers on. An unspecified address stands for every
205/// address of its family, and a dual-stack listener stands for the IPv4
206/// wildcard as well.
207fn listening_addrs(listener: &TcpListener) -> Result<impl Iterator<Item = SocketAddr> + use<>> {
208	let addr = listener.local_addr()?;
209
210	#[cfg(unix)]
211	let dual_stack = addr.is_ipv6() && addr.ip().is_unspecified() && !is_ipv6_only(listener)?;
212	#[cfg(not(unix))]
213	let dual_stack = false;
214
215	let wildcard = dual_stack.then(|| SocketAddr::new(Ipv4Addr::UNSPECIFIED.into(), addr.port()));
216
217	Ok(wildcard.into_iter().chain(once(addr)))
218}
219
220/// Whether a listener on one address answers for another, which is the case
221/// when they name the same socket or the listener holds the wider wildcard.
222fn covers(listening: &SocketAddr, addr: &SocketAddr) -> bool {
223	listening.port() == addr.port()
224		&& (listening.ip() == addr.ip()
225			|| (listening.ip().is_unspecified() && listening.is_ipv6() == addr.is_ipv6()))
226}
227
228/// Drops the configured unix socket when a passed listener already binds that
229/// path, which would otherwise be unlinked and replaced on the way up.
230#[cfg(unix)]
231fn unpassed_path<'a>(
232	path: Option<&'a Path>,
233	listeners: &[UnixListener],
234) -> Result<Option<&'a Path>> {
235	let Some(configured) = path else {
236		return Ok(None);
237	};
238
239	let covered = listeners
240		.iter()
241		.map(UnixListener::local_addr)
242		.process_results(|mut addrs| {
243			addrs.any(|addr| {
244				addr.as_pathname()
245					.is_some_and(|passed| same_path(configured, passed))
246			})
247		})?;
248
249	if covered {
250		info!(?configured, "Not binding: the service manager passed a listener for it.");
251	}
252
253	Ok(path.filter(|_| !covered))
254}
255
256/// Paths naming one socket, however the configuration spelled it.
257#[cfg(unix)]
258fn same_path(configured: &Path, passed: &Path) -> bool {
259	configured == passed
260		|| matches!(
261			(configured.canonicalize(), passed.canonicalize()),
262			(Ok(configured), Ok(passed)) if configured == passed
263		)
264}
265
266/// Binds the addresses nothing answers for yet, extending `listening` as it
267/// goes so a wildcard entry covers the ones behind it.
268///
269/// Failures surface here, before any listener is served. A defaulted address
270/// is skipped instead, since the built-in pair only guesses which loopback
271/// families the host has.
272fn bind_addrs(
273	addrs: &[SocketAddr],
274	listening: &mut Vec<SocketAddr>,
275	defaulted: bool,
276) -> Result<Vec<TcpListener>> {
277	let mut listeners = Vec::with_capacity(addrs.len());
278
279	// A dual-stack IPv6 socket answers for the IPv4 wildcard too, and the kernel
280	// refuses it once that wildcard is bound, so IPv6 goes first whatever order
281	// the configuration lists.
282	let mut addrs = addrs.to_vec();
283	addrs.sort_by_key(SocketAddr::is_ipv4);
284
285	for addr in &addrs {
286		if listening.iter().any(|other| covers(other, addr)) {
287			info!(%addr, "Not binding: a listener already answers for it.");
288			continue;
289		}
290
291		let listener = match TcpListener::bind(addr) {
292			| Ok(listener) => listener,
293			| Err(e) if defaulted => {
294				error!(%addr, %e, "Not binding: the default address is unavailable.");
295				continue;
296			},
297			| Err(e) => return Err!(Config("http.listen.address", "Failed to bind {addr}: {e}")),
298		};
299
300		listener.set_nonblocking(true)?;
301		listening.extend(listening_addrs(&listener)?);
302		listeners.push(listener);
303	}
304
305	Ok(listeners)
306}
307
308#[cfg(unix)]
309fn make_log_addrs(
310	tcp_listeners: &[TcpListener],
311	unix_path: Option<&Path>,
312	passed_tcp_listeners: &[TcpListener],
313	passed_unix_listeners: &[UnixListener],
314) -> Result<Vec<String>> {
315	let tcp_log_addrs = tcp_listeners
316		.iter()
317		.map(|listener| Ok(format!("tcp:{}", listener.local_addr()?)));
318
319	let unix_log_addr = unix_path.as_ref().map(|socket_path| {
320		let path = socket_path.to_string_lossy();
321
322		format!("unix:{path}")
323	});
324
325	let passed_tcp_log_addrs = passed_tcp_listeners.iter().map(|listener| {
326		let addr = listener.local_addr()?;
327
328		Ok(format!("passed:tcp:{addr}"))
329	});
330
331	let passed_unix_log_addrs = passed_unix_listeners.iter().map(|listener| {
332		let addr = listener.local_addr()?;
333		let log_path = addr
334			.as_pathname()
335			.map_or(Cow::Borrowed("?"), Path::to_string_lossy);
336
337		Ok(format!("passed:unix:{log_path}"))
338	});
339
340	tcp_log_addrs
341		.chain(unix_log_addr.into_iter().map(Ok))
342		.chain(passed_tcp_log_addrs)
343		.chain(passed_unix_log_addrs)
344		.collect()
345}
346
347#[cfg(all(unix, feature = "systemd", target_os = "linux"))]
348fn systemd_listeners() -> Result<(Vec<TcpListener>, Vec<UnixListener>)> {
349	use std::os::fd::FromRawFd;
350
351	use tuwunel_core::utils::sys::{SocketFamily, get_socket_family};
352
353	let mut tcp = vec![];
354	let mut unix = vec![];
355
356	for fd in sd_notify::listen_fds()? {
357		debug_assert!(fd >= 3, "fdno probably not a listener socket");
358
359		let family = get_socket_family(fd)?;
360
361		match family {
362			| SocketFamily::Inet => {
363				// SAFETY: systemd should already take care of providing
364				// the correct TCP socket, so we just use it via raw fd
365				let listener = unsafe { TcpListener::from_raw_fd(fd) };
366
367				listener.set_nonblocking(true)?;
368
369				tcp.push(listener);
370			},
371			| SocketFamily::Unix => {
372				// SAFETY: systemd should already take care of providing
373				// the correct UNIX socket, so we just use it via raw fd
374				let listener = unsafe { UnixListener::from_raw_fd(fd) };
375
376				listener.set_nonblocking(true)?;
377
378				unix.push(listener);
379			},
380		}
381	}
382
383	Ok((tcp, unix))
384}
385
386#[cfg(all(
387	unix,
388	any(not(feature = "systemd"), not(target_os = "linux"))
389))]
390fn systemd_listeners() -> Result<(Vec<TcpListener>, Vec<UnixListener>)> { Ok((vec![], vec![])) }
391
392#[cfg(not(unix))]
393fn make_log_addrs(
394	tcp_listeners: &[TcpListener],
395	unix_path: Option<&Path>,
396	passed_tcp_listeners: &[TcpListener],
397) -> Result<Vec<String>> {
398	let tcp_log_addrs = tcp_listeners
399		.iter()
400		.map(|listener| Ok(format!("tcp:{}", listener.local_addr()?)));
401
402	let unix_log_addr = unix_path.as_ref().map(|socket_path| {
403		let path = socket_path.to_string_lossy();
404		format!("unix:{path}")
405	});
406
407	let passed_tcp_log_addrs = passed_tcp_listeners.iter().map(|listener| {
408		let addr = listener.local_addr()?;
409		Ok(format!("passed:tcp:{addr}"))
410	});
411
412	tcp_log_addrs
413		.chain(unix_log_addr.into_iter().map(Ok))
414		.chain(passed_tcp_log_addrs)
415		.collect()
416}