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
26pub(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#[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
204fn 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
220fn 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#[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#[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
266fn 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 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 let listener = unsafe { TcpListener::from_raw_fd(fd) };
366
367 listener.set_nonblocking(true)?;
368
369 tcp.push(listener);
370 },
371 | SocketFamily::Unix => {
372 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}