use std::error::Error;
use std::net::{IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
use std::path::PathBuf;
use std::time::Duration;
use clap::{Args, ValueEnum};
use pb_mapper_auth::{
AuthConfig, AuthConfigOverrides, LegacyProtocolPolicy, MAX_TEMP_KEY_CAPACITY, MAX_TEMP_KEY_TTL,
MIN_TEMP_KEY_TTL, acquire_state_dir_lock, initialize_admin_key,
};
use pb_mapper_core::checksum::{
MACHINE_MSG_HEADER_KEY_PATH, set_process_msg_header_key, setup_machine_msg_header_key,
};
use pb_mapper_core::config::keep_alive_from_env;
use pb_mapper_server::DirectServerConfig;
use tokio_util::sync::CancellationToken;
use crate::{parse_duration, stop_requests};
#[derive(Debug, Args)]
pub(super) struct ServerArgs {
#[arg(long)]
quic_listen: Option<SocketAddr>,
#[arg(long, requires = "quic_listen", default_value_t = 0)]
quic_advertise_port: u16,
#[arg(short, long, visible_alias = "pb-mapper-port", default_value_t = 7666)]
port: u16,
#[arg(
long,
visible_alias = "disable-direct",
conflicts_with_all = ["enable_direct", "direct_listen", "direct_advertise"]
)]
relay_only: bool,
#[arg(long, hide = true)]
enable_direct: bool,
#[arg(long)]
direct_listen: Option<SocketAddr>,
#[arg(long)]
direct_advertise: Option<SocketAddr>,
#[arg(long, visible_alias = "use-ipv6", default_value_t = false)]
ipv6: bool,
#[arg(long, default_value_t = false)]
keep_alive: bool,
#[arg(long, default_value_t = false)]
use_machine_msg_header_key: bool,
#[arg(long)]
auth_state_dir: Option<PathBuf>,
#[arg(
long,
conflicts_with = "use_machine_msg_header_key",
default_value_t = false
)]
init_admin_key: bool,
#[arg(long, requires = "init_admin_key", default_value_t = false)]
force_init_admin_key: bool,
#[arg(long)]
max_temporary_keys: Option<usize>,
#[arg(long, value_parser = parse_duration)]
max_temporary_key_ttl: Option<Duration>,
#[arg(long, value_enum)]
legacy_protocol: Option<LegacyProtocolArg>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, ValueEnum)]
pub(super) enum LegacyProtocolArg {
Allow,
Deny,
}
impl From<LegacyProtocolArg> for LegacyProtocolPolicy {
fn from(value: LegacyProtocolArg) -> Self {
match value {
LegacyProtocolArg::Allow => Self::Allow,
LegacyProtocolArg::Deny => Self::Deny,
}
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
enum ServerFlagError {
MaxTemporaryKeys,
MaxTemporaryKeyTtl,
}
impl std::fmt::Display for ServerFlagError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::MaxTemporaryKeys => write!(
f,
"`--max-temporary-keys` must be between 1 and {MAX_TEMP_KEY_CAPACITY}"
),
Self::MaxTemporaryKeyTtl => write!(
f,
"`--max-temporary-key-ttl` must be between {}s and {}d",
MIN_TEMP_KEY_TTL.as_secs(),
MAX_TEMP_KEY_TTL.as_secs() / 86_400
),
}
}
}
impl Error for ServerFlagError {}
fn server_auth_config(args: &ServerArgs) -> Result<AuthConfig, ServerFlagError> {
if let Some(max_temporary_keys) = args.max_temporary_keys
&& !(1..=MAX_TEMP_KEY_CAPACITY).contains(&max_temporary_keys)
{
return Err(ServerFlagError::MaxTemporaryKeys);
}
if let Some(max_temporary_key_ttl) = args.max_temporary_key_ttl
&& !(MIN_TEMP_KEY_TTL..=MAX_TEMP_KEY_TTL).contains(&max_temporary_key_ttl)
{
return Err(ServerFlagError::MaxTemporaryKeyTtl);
}
Ok(AuthConfig::from_env_with(AuthConfigOverrides {
state_dir: args.auth_state_dir.clone(),
max_temporary_keys: args.max_temporary_keys,
max_temporary_key_ttl: args.max_temporary_key_ttl,
legacy_protocol: args.legacy_protocol.map(Into::into),
}))
}
pub(super) async fn run_server(args: ServerArgs) -> Result<(), Box<dyn Error>> {
let stop = stop_requests()?;
let auth_config = server_auth_config(&args)?;
let admin_key_path = pb_mapper_auth::admin_key_path(&auth_config.state_dir);
if args.init_admin_key {
std::fs::create_dir_all(&auth_config.state_dir)?;
let lock = acquire_state_dir_lock(&auth_config.state_dir)?;
let key = initialize_admin_key(&admin_key_path, args.force_init_admin_key)?;
drop(lock);
set_process_msg_header_key(Some(&key))?;
eprintln!(
"administrator key initialized at {}",
admin_key_path.display()
);
} else if args.use_machine_msg_header_key {
if admin_key_path.exists() {
return Err(format!(
"--use-machine-msg-header-key cannot replace `{}`; use `pb-mapper admin root-key rotate` to change the root key",
admin_key_path.display()
)
.into());
}
tracing::warn!(
"--use-machine-msg-header-key is a legacy compatibility option; prefer a random administrator key"
);
setup_machine_msg_header_key()?;
tracing::info!(
path = MACHINE_MSG_HEADER_KEY_PATH,
"derived and persisted machine MSG_HEADER_KEY"
);
}
let ip_addr = if args.ipv6 {
IpAddr::V6(Ipv6Addr::UNSPECIFIED)
} else {
IpAddr::V4(Ipv4Addr::UNSPECIFIED)
};
let shutdown = CancellationToken::new();
let keep_alive = args.keep_alive || keep_alive_from_env();
let options = pb_mapper_server::RelayServerOptions {
direct: direct_config(&args, ip_addr),
quic: args
.quic_listen
.map(|listen| pb_mapper_server::QuicServerConfig {
listen,
advertise_port: args.quic_advertise_port,
}),
};
let auth = pb_mapper_auth::AuthRuntime::from_process(auth_config).await?;
let listener = pb_mapper_core::listener::bind(SocketAddr::new(ip_addr, args.port))?;
let relay = pb_mapper_server::run_server_on_listener_with_options(
listener,
shutdown.clone(),
None,
keep_alive,
auth,
options,
);
let mut relay = std::pin::pin!(relay);
tokio::select! {
result = &mut relay => return Ok(result?),
() = stop => {}
}
tracing::info!(
event = "relay_stopping",
"asked to stop; stopping the relay"
);
shutdown.cancel();
let again = stop_requests()?;
tokio::select! {
result = &mut relay => result?,
() = again => tracing::warn!(
event = "relay_stopped_at_once",
"asked to stop again; not waiting for the relay to finish"
),
}
Ok(())
}
fn direct_config(args: &ServerArgs, ip_addr: IpAddr) -> Option<DirectServerConfig> {
let explicit =
args.enable_direct || args.direct_listen.is_some() || args.direct_advertise.is_some();
if args.relay_only || (!explicit && !cfg!(feature = "p2p")) {
return None;
}
if !explicit {
return match DirectServerConfig::probe_relay_port(ip_addr, args.port) {
Ok(config) => Some(config),
Err(error) => {
let listen = SocketAddr::new(ip_addr, args.port);
tracing::warn!(
event = "direct_service_unavailable",
%listen,
%error,
"UDP port unavailable; serving relay only (pass --direct-listen to choose another)"
);
None
}
};
}
let defaults = DirectServerConfig::on_relay_port(ip_addr, args.port);
Some(DirectServerConfig {
listen: args.direct_listen.unwrap_or(defaults.listen),
advertise: args.direct_advertise.unwrap_or(defaults.advertise),
})
}
#[cfg(test)]
mod tests {
use clap::Parser;
use super::*;
use crate::{Cli, Command};
fn server_args(args: &[&str]) -> ServerArgs {
let cli = Cli::try_parse_from(["pb-mapper", "server"].iter().chain(args))
.expect("server flags should parse");
let Command::Server(args) = cli.command else {
panic!("expected server command");
};
args
}
#[cfg(feature = "p2p")]
#[test]
fn direct_is_on_by_default_on_the_relay_port_over_udp() {
let ip = IpAddr::V4(Ipv4Addr::LOCALHOST);
let config =
direct_config(&server_args(&["--port", "0"]), ip).expect("direct is the default");
assert_eq!(config.listen, SocketAddr::new(ip, 0));
assert!(config.advertise.ip().is_unspecified());
assert!(direct_config(&server_args(&["--relay-only"]), ip).is_none());
assert!(direct_config(&server_args(&["--disable-direct"]), ip).is_none());
}
#[test]
fn server_direct_flags_from_0_7_still_parse_and_override_the_defaults() {
let args = server_args(&[
"--enable-direct",
"--direct-listen",
"0.0.0.0:10811",
"--direct-advertise",
"203.0.113.7:10811",
]);
let config = direct_config(&args, IpAddr::V4(Ipv4Addr::UNSPECIFIED))
.expect("explicit direct configuration");
assert_eq!(config.listen, "0.0.0.0:10811".parse().unwrap());
assert_eq!(config.advertise, "203.0.113.7:10811".parse().unwrap());
assert!(
Cli::try_parse_from(["pb-mapper", "server", "--relay-only", "--enable-direct"])
.is_err()
);
}
#[test]
fn server_auth_options_only_override_environment_when_explicit() {
let defaults = server_args(&[]);
assert_eq!(defaults.auth_state_dir, None);
assert_eq!(defaults.quic_listen, None);
assert_eq!(defaults.max_temporary_keys, None);
assert_eq!(defaults.max_temporary_key_ttl, None);
assert_eq!(defaults.legacy_protocol, None);
let explicit = server_auth_config(&server_args(&[
"--auth-state-dir",
"/tmp/pb-mapper-auth",
"--max-temporary-keys",
"1024",
"--max-temporary-key-ttl",
"2h",
"--legacy-protocol",
"deny",
]))
.unwrap();
assert_eq!(explicit.state_dir, PathBuf::from("/tmp/pb-mapper-auth"));
assert_eq!(explicit.max_temporary_keys, 1024);
assert_eq!(
explicit.max_temporary_key_ttl,
Duration::from_secs(2 * 60 * 60)
);
assert_eq!(explicit.legacy_protocol, LegacyProtocolPolicy::Deny);
}
#[test]
fn explicit_out_of_range_server_auth_flags_are_rejected() {
assert_eq!(
server_auth_config(&server_args(&["--max-temporary-keys", "0"])).unwrap_err(),
ServerFlagError::MaxTemporaryKeys
);
assert_eq!(
server_auth_config(&server_args(&["--max-temporary-key-ttl", "5s"])).unwrap_err(),
ServerFlagError::MaxTemporaryKeyTtl
);
}
}