mod answer;
use std::net::{Ipv4Addr, SocketAddr};
use std::sync::{Arc, RwLock};
use prolink_proto::rpc::{mount, nfs2, portmap};
use tokio::net::UdpSocket;
use tokio::sync::Semaphore;
use tokio::task::JoinHandle;
use tracing::{debug, info, warn};
use crate::interface::Interface;
use crate::serve::vfs::Vfs;
use crate::socket::{self, MAX_DATAGRAM};
use crate::{Error, Result};
use answer::{Dispatcher, Service};
pub use answer::Mount;
pub const MAX_IN_FLIGHT: usize = 64;
const NOT_PERMITTED: &str = if cfg!(target_os = "linux") {
"run as root, grant this binary CAP_NET_BIND_SERVICE, or lower the privileged range with \
`sysctl -w net.ipv4.ip_unprivileged_port_start=111`"
} else if cfg!(target_os = "macos") {
"macOS has no unprivileged-port setting, so serving files to a player requires running as root"
} else {
"ports below 1024 usually require elevated privileges"
};
const ALREADY_HELD: &str = "another RPC server already holds it — on Linux that is usually \
`rpcbind` or `nfs-server`, and stopping them frees it; sharing the \
port is not an option, because the two servers would each receive \
some of a player's calls";
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
pub struct Ports {
pub portmap: u16,
pub mount: u16,
pub nfs: u16,
}
impl Ports {
pub fn is_discoverable(&self) -> bool {
self.portmap == portmap::PORT
}
}
#[derive(Clone, Debug)]
pub struct NfsConfig {
pub interface: Option<Interface>,
pub portmap_port: u16,
pub mount_port: u16,
pub nfs_port: u16,
}
impl Default for NfsConfig {
fn default() -> Self {
Self {
interface: None,
portmap_port: portmap::PORT,
mount_port: mount::PIONEER_PORT,
nfs_port: nfs2::PORT,
}
}
}
#[derive(Debug)]
pub struct NfsServer {
ports: Ports,
dispatcher: Arc<Dispatcher>,
tasks: Vec<JoinHandle<()>>,
}
impl NfsServer {
#[expect(
clippy::unused_async,
reason = "spawns tasks, so it needs a tokio runtime; async is how that is documented \
at the call site, and keeps the signature stable if setup later awaits"
)]
pub async fn start(vfs: Arc<RwLock<Vfs>>, config: NfsConfig) -> Result<Self> {
let interface = config.interface.as_ref();
let (nfs, nfs_port) = bind_preferred(config.nfs_port, interface, "nfsd")?;
let (mount, mount_port) = bind_preferred(config.mount_port, interface, "mountd")?;
let portmap = bind_portmapper(config.portmap_port, interface)?;
let portmap_port = port_of(&portmap)?;
let ports = Ports {
portmap: portmap_port,
mount: mount_port,
nfs: nfs_port,
};
if ports.is_discoverable() {
info!(
portmap = ports.portmap,
mount = ports.mount,
nfs = ports.nfs,
"serving files",
);
} else {
warn!(
portmap = ports.portmap,
"the portmapper is not on {}: a player will retry GETPORT indefinitely, never \
fall back to the well-known ports, and never list us (F46)",
portmap::PORT,
);
}
let dispatcher = Arc::new(Dispatcher::new(vfs, ports));
let limit = Arc::new(Semaphore::new(MAX_IN_FLIGHT));
let tasks = [
(portmap, Service::Portmap),
(mount, Service::Mount),
(nfs, Service::Nfs),
]
.into_iter()
.map(|(socket, service)| {
listen(
Arc::new(socket),
service,
Arc::clone(&dispatcher),
Arc::clone(&limit),
)
})
.collect();
Ok(Self {
ports,
dispatcher,
tasks,
})
}
pub fn ports(&self) -> Ports {
self.ports
}
pub fn mounts(&self) -> Vec<Mount> {
self.dispatcher.mounts()
}
}
impl Drop for NfsServer {
fn drop(&mut self) {
for task in &self.tasks {
task.abort();
}
}
}
fn listen(
socket: Arc<UdpSocket>,
service: Service,
dispatcher: Arc<Dispatcher>,
limit: Arc<Semaphore>,
) -> JoinHandle<()> {
tokio::spawn(async move {
let mut buffer = vec![0u8; MAX_DATAGRAM];
loop {
let (len, from) = match socket.recv_from(&mut buffer).await {
Ok(received) => received,
Err(error) => {
warn!(%error, ?service, "socket closed");
return;
}
};
let SocketAddr::V4(from) = from else { continue };
let Some(datagram) = buffer.get(..len) else {
continue;
};
let Ok(permit) = Arc::clone(&limit).try_acquire_owned() else {
debug!(?service, %from, "at {MAX_IN_FLIGHT} calls in flight; dropping one");
continue;
};
let datagram = datagram.to_vec();
let dispatcher = Arc::clone(&dispatcher);
let socket = Arc::clone(&socket);
tokio::spawn(async move {
let _permit = permit;
let answered = tokio::task::spawn_blocking(move || {
dispatcher.answer(service, &datagram, *from.ip())
})
.await;
match answered {
Ok(Some(reply)) => {
if let Err(error) = socket.send_to(&reply, SocketAddr::V4(from)).await {
warn!(%error, %from, "reply not sent");
}
}
Ok(None) => {}
Err(error) => warn!(%error, ?service, "answering panicked"),
}
});
}
})
}
fn bind_preferred(
preferred: u16,
interface: Option<&Interface>,
what: &'static str,
) -> Result<(UdpSocket, u16)> {
let socket = match socket::bind_exclusive(Ipv4Addr::UNSPECIFIED, preferred, interface) {
Ok(socket) => socket,
Err(error) => {
warn!(%error, what, wanted = preferred, "port taken; using an ephemeral one");
socket::bind_exclusive(Ipv4Addr::UNSPECIFIED, 0, interface)?
}
};
let port = port_of(&socket)?;
Ok((socket, port))
}
fn bind_portmapper(port: u16, interface: Option<&Interface>) -> Result<UdpSocket> {
match socket::bind_exclusive(Ipv4Addr::UNSPECIFIED, port, interface) {
Ok(socket) => Ok(socket),
Err(Error::Io { source, .. }) => {
let remedy = if source.kind() == std::io::ErrorKind::AddrInUse {
ALREADY_HELD
} else {
NOT_PERMITTED
};
Err(Error::PrivilegedPort {
port,
source,
remedy,
})
}
Err(other) => Err(other),
}
}
fn port_of(socket: &UdpSocket) -> Result<u16> {
Ok(
match socket
.local_addr()
.map_err(Error::io("reading a bound port"))?
{
SocketAddr::V4(address) => address.port(),
SocketAddr::V6(address) => address.port(),
},
)
}
#[cfg(test)]
mod tests {
use super::*;
use std::net::Ipv4Addr;
use std::time::Duration;
use prolink_proto::rpc::nfs2::{FileHandle, ReadArgs};
use prolink_proto::rpc::xdr::Utf16LeString;
use prolink_proto::rpc::{Auth, AuthUnix, Call, IpProtocol, Program, Reply, Xid};
fn medium() -> (Arc<RwLock<Vfs>>, Vec<u8>) {
let audio: Vec<u8> = (0..=255u8).cycle().take(100_000).collect();
let mut vfs = Vfs::new();
vfs.add_file("/C/PIONEER/rekordbox/export.pdb", b"pdb".to_vec());
vfs.add_file("/C/Contents/GESAFFELSTEIN/track.mp3", audio.clone());
(Arc::new(RwLock::new(vfs)), audio)
}
fn ephemeral() -> NfsConfig {
NfsConfig {
interface: None,
portmap_port: 0,
mount_port: 0,
nfs_port: 0,
}
}
fn at(port: u16) -> SocketAddr {
SocketAddr::new(Ipv4Addr::LOCALHOST.into(), port)
}
async fn round_trip(client: &UdpSocket, port: u16, call: &[u8]) -> Vec<u8> {
client
.send_to(call, at(port))
.await
.expect("a call goes out");
let mut buffer = vec![0u8; MAX_DATAGRAM];
let (len, _) = tokio::time::timeout(Duration::from_secs(5), client.recv_from(&mut buffer))
.await
.expect("a reply arrives within five seconds")
.expect("a reply is received");
buffer.truncate(len);
buffer
}
fn encode(
program: Program,
version: u32,
procedure: u32,
arguments: &[u8],
xid: u32,
) -> Vec<u8> {
let credential =
AuthUnix::cdj(prolink_proto::rpc::stamp_for_xid(Xid(xid)).unwrap_or(0)).encode();
Call::new(
Xid(xid),
program,
version,
procedure,
Auth::unix(&credential),
arguments,
)
.encode()
}
fn results(datagram: &[u8]) -> Vec<u8> {
Reply::parse(datagram)
.expect("a reply must decode")
.results()
.expect("a successful reply")
.to_vec()
}
#[tokio::test]
async fn a_player_can_find_mount_walk_and_stream() {
let (vfs, audio) = medium();
let server = NfsServer::start(vfs, ephemeral())
.await
.expect("ephemeral ports need no privileges");
let ports = server.ports();
assert!(
!ports.is_discoverable(),
"a portmapper off 111 is not one hardware would find",
);
let client = socket::bind(0, None).expect("a client socket");
let getport = encode(
Program::PORTMAP,
portmap::VERSION,
portmap::Proc::GETPORT.0,
&portmap::Request::GetPort(portmap::Mapping::query(
Program::MOUNT,
mount::VERSION,
IpProtocol::UDP,
))
.encode_arguments(),
1,
);
let reply = round_trip(&client, ports.portmap, &getport).await;
assert_eq!(
portmap::Response::parse(portmap::Proc::GETPORT, &results(&reply)).unwrap(),
portmap::Response::GetPort(Some(ports.mount)),
);
let mnt = encode(
Program::MOUNT,
mount::VERSION,
mount::Proc::MNT.0,
&mount::Request::Mnt(Utf16LeString::new(mount::EXPORT_USB)).encode_arguments(),
2,
);
let reply = round_trip(&client, ports.mount, &mnt).await;
let mount::Response::Mnt(Ok(root)) =
mount::Response::parse(mount::Proc::MNT, &results(&reply)).unwrap()
else {
panic!("the USB export must mount");
};
assert_eq!(server.mounts().len(), 1, "and the server remembers it");
let mut handle = root;
for (index, component) in ["Contents", "GESAFFELSTEIN", "track.mp3"]
.into_iter()
.enumerate()
{
let mut sent = handle;
sent.0[FileHandle::KEY_LEN..].copy_from_slice(&[0xab; 20]);
let lookup = encode(
Program::NFS,
nfs2::VERSION,
nfs2::Proc::LOOKUP.0,
&nfs2::Request::Lookup {
dir: sent,
name: Utf16LeString::new(component),
}
.encode_arguments(),
u32::try_from(index).unwrap_or(0) + 3,
);
let reply = round_trip(&client, ports.nfs, &lookup).await;
let nfs2::Response::Lookup(Ok(found)) =
nfs2::Response::parse(nfs2::Proc::LOOKUP, &results(&reply)).unwrap()
else {
panic!("{component} must resolve");
};
handle = found.handle;
}
let mut streamed = Vec::new();
while streamed.len() < audio.len() {
let offset = u64::try_from(streamed.len()).unwrap();
let read = encode(
Program::NFS,
nfs2::VERSION,
nfs2::Proc::READ.0,
&nfs2::Request::Read(ReadArgs::at(handle, offset, 8192).unwrap())
.encode_arguments(),
9,
);
let reply = round_trip(&client, ports.nfs, &read).await;
let payload = results(&reply);
let nfs2::Response::Read(Ok(data)) =
nfs2::Response::parse(nfs2::Proc::READ, &payload).unwrap()
else {
panic!("a read at {offset} must succeed");
};
assert!(!data.data.is_empty(), "no progress at {offset}");
streamed.extend_from_slice(data.data);
}
assert_eq!(streamed, audio, "the bytes that come back are the file");
}
#[tokio::test]
async fn a_medium_grafted_in_after_the_server_started_is_served() {
let vfs = Arc::new(RwLock::new(Vfs::new()));
let server = NfsServer::start(Arc::clone(&vfs), ephemeral())
.await
.expect("start");
let client = socket::bind(0, None).expect("a client socket");
let mnt = encode(
Program::MOUNT,
mount::VERSION,
mount::Proc::MNT.0,
&mount::Request::Mnt(Utf16LeString::new(mount::EXPORT_USB)).encode_arguments(),
1,
);
let reply = round_trip(&client, server.ports().mount, &mnt).await;
assert!(
matches!(
mount::Response::parse(mount::Proc::MNT, &results(&reply)).unwrap(),
mount::Response::Mnt(Err(_)),
),
"an empty slot has nothing to mount",
);
vfs.write()
.expect("the tree")
.add_file("/C/PIONEER/rekordbox/export.pdb", b"pdb".to_vec());
let reply = round_trip(&client, server.ports().mount, &mnt).await;
assert!(
matches!(
mount::Response::parse(mount::Proc::MNT, &results(&reply)).unwrap(),
mount::Response::Mnt(Ok(_)),
),
"and now there is",
);
}
#[tokio::test]
async fn a_second_server_cannot_take_the_ports_of_the_first() {
let (vfs, _) = medium();
let first = NfsServer::start(Arc::clone(&vfs), ephemeral())
.await
.expect("the first server starts");
let held = NfsConfig {
interface: None,
portmap_port: first.ports().portmap,
mount_port: first.ports().mount,
nfs_port: first.ports().nfs,
};
let error = NfsServer::start(vfs, held)
.await
.expect_err("the portmapper's port is already held");
assert!(
matches!(&error, Error::PrivilegedPort { source, .. }
if source.kind() == std::io::ErrorKind::AddrInUse),
"{error:?}",
);
assert!(
error.to_string().contains("already holds it"),
"the remedy must be the one for a clash, not the one for privilege: {error}",
);
}
#[tokio::test]
async fn a_reply_comes_back_from_the_port_the_call_went_to() {
let (vfs, _) = medium();
let server = NfsServer::start(vfs, ephemeral()).await.expect("start");
let client = socket::bind(0, None).expect("a client socket");
let null = encode(Program::NFS, nfs2::VERSION, nfs2::Proc::NULL.0, &[], 1);
client
.send_to(&null, at(server.ports().nfs))
.await
.expect("a call goes out");
let mut buffer = vec![0u8; MAX_DATAGRAM];
let (_, from) = tokio::time::timeout(Duration::from_secs(5), client.recv_from(&mut buffer))
.await
.expect("a reply arrives")
.expect("a reply is received");
assert_eq!(from.port(), server.ports().nfs);
}
#[test]
fn the_defaults_are_the_numbers_a_cdj_publishes() {
let config = NfsConfig::default();
assert_eq!(config.portmap_port, 111);
assert_eq!(config.mount_port, 48276);
assert_eq!(config.nfs_port, 2049);
assert!(
Ports {
portmap: 111,
mount: 48276,
nfs: 2049,
}
.is_discoverable()
);
}
#[tokio::test]
async fn a_dropped_server_stops_answering() {
let (vfs, _) = medium();
let server = NfsServer::start(vfs, ephemeral()).await.expect("start");
let port = server.ports().nfs;
let client = socket::bind(0, None).expect("a client socket");
let null = encode(Program::NFS, nfs2::VERSION, nfs2::Proc::NULL.0, &[], 1);
let reply = round_trip(&client, port, &null).await;
assert_eq!(reply.len(), 24);
drop(server);
tokio::task::yield_now().await;
client
.send_to(&null, at(port))
.await
.expect("a call goes out");
let mut buffer = vec![0u8; MAX_DATAGRAM];
assert!(
tokio::time::timeout(Duration::from_millis(250), client.recv_from(&mut buffer))
.await
.is_err(),
"a dropped server has closed its sockets",
);
}
}