mod analysis;
mod keys;
mod menu;
mod plain;
use std::collections::{BTreeMap, VecDeque};
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
use std::sync::{Arc, Mutex};
use std::time::Instant;
use prolink_proto::dbserver::{
self, Descriptor, MAX_RENDER_BATCH, MenuItem, Message, MessageKind, PORT, PORT_QUERY_PORT,
PREAMBLE,
};
use prolink_proto::{BrowsableDeviceNumber, Slot};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::{TcpListener, TcpStream};
use tokio::task::JoinHandle;
use tracing::{debug, info, warn};
use crate::serve::medium::{Medium, ServedSlot};
use crate::serve::player::MediaSet;
use crate::virtual_cdj::LoadedTracks;
use crate::{Error, Result};
pub const MAX_PENDING_MENUS: usize = 32;
const READ_CHUNK: usize = 16 * 1024;
#[derive(Clone, Copy, Debug)]
pub struct DbServerConfig {
pub device: BrowsableDeviceNumber,
pub address: Ipv4Addr,
pub port: u16,
pub query_port: Option<u16>,
}
impl Default for DbServerConfig {
#[expect(
clippy::unwrap_used,
reason = "1 is a browsable device number by inspection, and `Option` has no const unwrap \
to prove it with instead"
)]
fn default() -> Self {
Self {
device: BrowsableDeviceNumber::new(1).unwrap(),
address: Ipv4Addr::UNSPECIFIED,
port: PORT,
query_port: Some(PORT_QUERY_PORT),
}
}
}
#[derive(Debug)]
pub struct DbServer {
shared: Arc<Shared>,
port: u16,
query_port: Option<u16>,
tasks: Vec<JoinHandle<()>>,
}
#[derive(Debug, Default)]
struct TagLists {
by_device: Mutex<BTreeMap<(u8, Slot), Vec<u32>>>,
}
impl TagLists {
fn set(&self, device: u8, slot: Slot, track: u32, add: bool) {
let Ok(mut lists) = self.by_device.lock() else {
return;
};
let list = lists.entry((device, slot)).or_default();
match (add, list.iter().position(|&id| id == track)) {
(true, None) => list.push(track),
(false, Some(at)) => {
list.remove(at);
}
_ => {}
}
}
fn clear(&self, device: u8, slot: Slot) {
if let Ok(mut lists) = self.by_device.lock() {
lists.remove(&(device, slot));
}
}
fn get(&self, device: u8, slot: Slot) -> Vec<u32> {
self.by_device
.lock()
.ok()
.and_then(|lists| lists.get(&(device, slot)).cloned())
.unwrap_or_default()
}
}
#[derive(Debug)]
struct Shared {
device: BrowsableDeviceNumber,
tags: TagLists,
loaded: Arc<LoadedTracks>,
media: Arc<MediaSet>,
started: Instant,
}
impl Shared {
fn medium(&self, slot: Slot) -> Option<Arc<Medium>> {
if let Some(medium) = self.media.get(slot) {
return Some(medium);
}
let mut media = self.media.all().into_iter();
match (media.next(), media.next()) {
(Some(only), None) => Some(only),
_ => None,
}
}
}
impl DbServer {
pub async fn start(
config: DbServerConfig,
media: impl IntoIterator<Item = Arc<Medium>>,
) -> Result<Self> {
Self::start_watching(
config,
Arc::new(MediaSet::new(media)),
Arc::new(LoadedTracks::default()),
)
.await
}
pub async fn start_watching(
config: DbServerConfig,
media: Arc<MediaSet>,
loaded: Arc<LoadedTracks>,
) -> Result<Self> {
let listener = bind(config.address, config.port).await?;
let port = local_port(&listener)?;
let shared = Arc::new(Shared {
device: config.device,
tags: TagLists::default(),
loaded: Arc::clone(&loaded),
media,
started: Instant::now(),
});
let mut tasks = vec![spawn_dbserver(listener, Arc::clone(&shared))];
let query_port = match config.query_port {
None => None,
Some(wanted) => match bind_exactly(
config.address,
wanted,
"binding the dbserver port-query port",
)
.await
{
Ok(listener) => {
let bound = local_port(&listener)?;
tasks.push(spawn_port_query(listener, port));
Some(bound)
}
Err(error) => {
warn!(
%error,
port = wanted,
"could not answer the dbserver port query; players will not find us"
);
None
}
},
};
info!(
port,
query_port,
device = %config.device,
slots = shared.media.len(),
"dbserver listening"
);
Ok(Self {
shared,
port,
query_port,
tasks,
})
}
pub fn port(&self) -> u16 {
self.port
}
pub fn query_port(&self) -> Option<u16> {
self.query_port
}
pub fn slots(&self) -> Vec<ServedSlot> {
self.shared
.media
.all()
.iter()
.map(|medium| medium.slot())
.collect()
}
}
impl Drop for DbServer {
fn drop(&mut self) {
for task in &self.tasks {
task.abort();
}
}
}
async fn bind(address: Ipv4Addr, port: u16) -> Result<TcpListener> {
match TcpListener::bind(SocketAddrV4::new(address, port)).await {
Ok(listener) => Ok(listener),
Err(_) if port != 0 => {
debug!(port, "port taken; falling back to an ephemeral one");
bind_exactly(address, 0, "binding an ephemeral dbserver port").await
}
Err(error) => Err(Error::io("binding the dbserver port")(error)),
}
}
async fn bind_exactly(address: Ipv4Addr, port: u16, what: &'static str) -> Result<TcpListener> {
TcpListener::bind(SocketAddrV4::new(address, port))
.await
.map_err(Error::io(what))
}
fn local_port(listener: &TcpListener) -> Result<u16> {
match listener
.local_addr()
.map_err(Error::io("reading a listener's address"))?
{
SocketAddr::V4(address) => Ok(address.port()),
SocketAddr::V6(address) => Ok(address.port()),
}
}
fn spawn_port_query(listener: TcpListener, port: u16) -> JoinHandle<()> {
tokio::spawn(async move {
loop {
let Ok((mut stream, peer)) = listener.accept().await else {
return;
};
tokio::spawn(async move {
let mut request = [0u8; dbserver::PORT_QUERY.len()];
let _ = stream.read(&mut request).await;
if stream
.write_all(&dbserver::encode_port_reply(port))
.await
.is_ok()
{
debug!(%peer, port, "told a peer where our dbserver is");
}
let _ = stream.shutdown().await;
});
}
})
}
fn spawn_dbserver(listener: TcpListener, shared: Arc<Shared>) -> JoinHandle<()> {
tokio::spawn(async move {
loop {
let Ok((stream, peer)) = listener.accept().await else {
return;
};
let shared = Arc::clone(&shared);
tokio::spawn(async move {
info!(%peer, "dbserver client connected");
if let Err(error) = serve(stream, &shared).await {
debug!(%peer, %error, "dbserver connection ended");
}
info!(%peer, "dbserver client disconnected");
});
}
})
}
async fn serve(mut stream: TcpStream, shared: &Shared) -> Result<()> {
let _ = stream.set_nodelay(true);
let mut buffer = Vec::with_capacity(READ_CHUNK);
while buffer.len() < PREAMBLE.len() {
if read_more(&mut stream, &mut buffer).await? == 0 {
return Ok(());
}
}
if dbserver::skip_preamble(&buffer).len() == buffer.len() {
return Err(Error::Protocol(prolink_proto::Error::BadMagic {
expected: PREAMBLE.as_slice().into(),
got: buffer.get(..PREAMBLE.len()).unwrap_or_default().into(),
}));
}
buffer.drain(..PREAMBLE.len());
stream
.write_all(&PREAMBLE)
.await
.map_err(Error::io("answering the dbserver preamble"))?;
let mut session = Session::default();
let mut out = Vec::new();
loop {
let mut consumed = 0;
let mut closing = false;
loop {
let rest = buffer.get(consumed..).unwrap_or_default();
match Message::decode(rest) {
Ok((message, used)) => {
consumed += used;
debug!(?message, "dbserver request");
if session.handle(shared, &message, &mut out) == Flow::Close {
closing = true;
break;
}
}
Err(error) if error.is_truncated() => break,
Err(error) => {
buffer.drain(..consumed);
flush(&mut stream, &mut out).await?;
return Err(error.into());
}
}
}
buffer.drain(..consumed);
flush(&mut stream, &mut out).await?;
if closing || read_more(&mut stream, &mut buffer).await? == 0 {
return Ok(());
}
}
}
async fn flush(stream: &mut TcpStream, out: &mut Vec<u8>) -> Result<()> {
if out.is_empty() {
return Ok(());
}
let result = stream
.write_all(out)
.await
.map_err(Error::io("writing a dbserver reply"));
out.clear();
result
}
async fn read_more(stream: &mut TcpStream, buffer: &mut Vec<u8>) -> Result<usize> {
let start = buffer.len();
buffer.resize(start + READ_CHUNK, 0);
let read = match stream
.read(buffer.get_mut(start..).unwrap_or_default())
.await
{
Ok(read) => read,
Err(error) => {
buffer.truncate(start);
return Err(Error::io("reading from a dbserver client")(error));
}
};
buffer.truncate(start + read);
Ok(read)
}
#[derive(Clone, Copy, PartialEq, Eq, Debug)]
enum Flow {
Continue,
Close,
}
#[derive(Debug, Default)]
struct Session {
menus: BTreeMap<(u32, u32), Arc<Vec<MenuItem>>>,
order: VecDeque<(u32, u32)>,
recent: BTreeMap<u32, Arc<Vec<MenuItem>>>,
last: Arc<Vec<MenuItem>>,
}
impl Session {
fn handle(&mut self, shared: &Shared, message: &Message, out: &mut Vec<u8>) -> Flow {
let transaction = message.transaction_id;
let kind = message.kind;
let descriptor = message.descriptor();
let slot = descriptor.map_or(Slot::NONE, |descriptor| descriptor.slot);
let medium = shared.medium(slot);
let medium = medium.as_deref();
match kind {
MessageKind::INTRODUCE => {
let mut reply = Message::introduce_reply(shared.device.number());
reply.transaction_id = transaction;
push(out, &reply);
return Flow::Continue;
}
MessageKind::DISCONNECT => return Flow::Close,
kind if kind.expects_no_reply() => return Flow::Continue,
MessageKind::UNKNOWN_3E03 => {
push(
out,
&Message::unknown_3e03_reply(transaction, shared.device.number()),
);
return Flow::Continue;
}
MessageKind::RENDER_MENU => {
self.render(shared, message, out);
return Flow::Continue;
}
MessageKind::UNKNOWN_3100 => {
let place = medium
.and_then(Medium::folders)
.and_then(|folders| folders.index_in_folder(message.number(1).unwrap_or(0)))
.unwrap_or(0);
push(out, &Message::success(transaction, kind, place));
return Flow::Continue;
}
MessageKind::TAG_LIST_CLEAR => {
if let Some(descriptor) = descriptor {
shared.tags.clear(descriptor.device.get(), descriptor.slot);
}
push(out, &Message::success(transaction, kind, 0));
return Flow::Continue;
}
MessageKind::TAG_LIST_ADD => {
if let (Some(descriptor), Some(track)) = (descriptor, message.number(1)) {
let add = message.number(2) != Some(0);
shared
.tags
.set(descriptor.device.get(), descriptor.slot, track, add);
}
push(out, &Message::success(transaction, kind, 0));
return Flow::Continue;
}
_ => {}
}
if analysis::is_binary_request(kind)
&& let Some(reply) = analysis::reply(message, medium, shared.started.elapsed())
{
push(out, &reply);
return Flow::Continue;
}
let tags = descriptor.map_or_else(Vec::new, |descriptor| {
shared.tags.get(descriptor.device.get(), descriptor.slot)
});
if let Some(items) = menu::build(kind, &message.args, medium, &tags) {
let count = u32::try_from(items.len()).unwrap_or(u32::MAX);
let raw = descriptor.map_or(0, Descriptor::to_raw);
self.remember(raw, count, items);
push(out, &Message::success(transaction, kind, count));
} else {
debug!(?kind, "acknowledged a request we do not implement");
push(out, &Message::success(transaction, kind, 0));
}
Flow::Continue
}
fn remember(&mut self, descriptor: u32, count: u32, items: Vec<MenuItem>) {
let key = (descriptor, count);
let items = Arc::new(items);
self.last = Arc::clone(&items);
self.recent.insert(descriptor, Arc::clone(&items));
self.menus.insert(key, items);
self.touch(key);
self.evict();
}
fn touch(&mut self, key: (u32, u32)) {
if let Some(position) = self.order.iter().position(|existing| *existing == key) {
self.order.remove(position);
}
self.order.push_back(key);
}
fn evict(&mut self) {
while self.order.len() > MAX_PENDING_MENUS {
if let Some(oldest) = self.order.pop_front() {
self.menus.remove(&oldest);
if self
.recent
.get(&oldest.0)
.is_some_and(|items| u32::try_from(items.len()).unwrap_or(u32::MAX) == oldest.1)
&& !self.order.iter().any(|key| key.0 == oldest.0)
{
self.recent.remove(&oldest.0);
}
}
}
}
fn render(&mut self, shared: &Shared, message: &Message, out: &mut Vec<u8>) {
let transaction = message.transaction_id;
let parsed = message.descriptor();
let descriptor = parsed.map_or(0, Descriptor::to_raw);
let offset = usize::try_from(message.number(1).unwrap_or(0)).unwrap_or(usize::MAX);
let limit = message
.number(2)
.unwrap_or(MAX_RENDER_BATCH)
.min(MAX_RENDER_BATCH);
let limit = usize::try_from(limit).unwrap_or(0);
let total = message.number(4).unwrap_or(0);
let key = (descriptor, total);
let items = self
.menus
.get(&key)
.or_else(|| self.recent.get(&descriptor))
.unwrap_or(&self.last)
.clone();
if self.menus.contains_key(&key) {
self.touch(key);
}
let (tags, playing) = parsed.map_or_else(
|| (Vec::new(), None),
|descriptor| {
let device = descriptor.device.get();
(
shared.tags.get(device, descriptor.slot),
shared.loaded.track_on(device, descriptor.slot),
)
},
);
push(out, &Message::menu_header(transaction));
for item in items.iter().skip(offset).take(limit) {
push(
out,
&menu::mark(item, &tags, playing).to_message(transaction),
);
}
push(out, &Message::menu_footer(transaction));
}
}
fn push(out: &mut Vec<u8>, message: &Message) {
out.extend_from_slice(&message.encode());
}
#[cfg(test)]
mod tests;